ich habe folgendes Problem bei dem Einsatz von Boost-Threads. Ich erstelle 4 Threads, die gemeinsam auf eine Liste zugreifen sollen. Hierzu habe ich einen globalen Index, der von jedem Thread inkrementiert werden kann und mit dem sich ein Thread ein Element aus der Liste zur Abarbeitung holen kann. Sowohl die Inkrementierung des Index', als auch die Abfrage des aktuellen Elements aus der Liste, befinden sich in einem geschützten Bereich. Alle Threads werden in einer Thread-Group zusammen gepackt und dann durch den Aufruf join_all() gestartet. Beim ersten Durchlauf scheinen alle Threads in etwa gleichzeitig in den geschützten Bereich zu gelangen bevor ein Thread den Bereich für die anderen blockieren kann. Das hat zur Folge, dass mehrmals das Element an Stelle 0 der Liste bearbeitet wird. Bei allen folgenden Durchläufen funktioniert die Sperre des geschützten Bereichs ohne Probleme. Gibt es eventuell eine Möglichkeit die Threads etwas zeitversetzt zu starten oder gibt es andere Lösungswege?

Abschließend stelle ich noch die entsprechenden Codeschnipsel zur Verfügung:

Erstellen der Thread-Group und starten der Threads:

boost::thread_group group;
for (int i = 0; i < NUM_THREADS; i++) {
    boost::thread *thread = new boost::thread(&ReportBuilder::loadFoils, this);
    group.add_thread(thread);
}
group.join_all();

Aufgerufene Methode der Threads mit Aufruf des geschützten Bereichs:

void ReportBuilder::loadFoils() {
    Statistics stat;
    for (foilListCounter = 0; foilListCounter < foilList.size();) {
        SmallFoilInfo inf = getFoilInfo();
        stat.loadFoil(inf, false);
    }
}

Aufgerufener geschützter Bereich:

SmallFoilInfo ReportBuilder::getFoilInfo() {
    boost::mutex::scoped_lock lock(mutex);
    int index = foilListCounter;
    cout << "index: " << index << endl;
    SmallFoilInfo info = foilList[index];
    foilListCounter++;
    return info;
}

Ausgabe der Konsole:

index: 0
index: 0
index: 0
index: 1
index: 2
index: 3
index: 4
index: 5
index: 6

Vielen Dank im Voraus!

Gruß,
Sven

for (foilListCounter = 0; foilListCounter < foilList.size();) {

while (foilListCounter < foilList.size()) {

Vielen Dank für die schnelle Hilfe!

Gruß,
Sven

Die Sofortlösung wäre

SmallFoilInfo ReportBuilder::getFoilInfo(int& index) {
    boost::mutex::scoped_lock lock(mutex);
    index = foilListCounter;
    cout << "index: " << index << endl;
    SmallFoilInfo info = foilList[index];
    foilListCounter++;
    return info;
}

void ReportBuilder::loadFoils() {
    Statistics stat;
    int counter;
    for (SmallFoilInfo inf = getFoilInfo(counter); counter<foilList.size(); inf = getFoilInfo(counter)) {
        stat.loadFoil(inf, false);
    }
}

Allgemein besser wäre eine lock-free Implementierung.

atomic<int> foilListCounter; // als Member (oder size_t)

bool ReportBuilder::getFoilInfo(SmallFoilInfo inf) {
    int index = foilListCounter.fetch_add(1); // threadsafe counter++
    if (index >= foilList.size())
        return false;
    inf = foilList[index];
    return true;
}

void ReportBuilder::loadFoils() {
    Statistics stat;
    for (SmallFoilInfo inf; getFoilInfo(inf);) {
        stat.loadFoil(inf, false);
    }
}