(einfach) boost thread_group Frage

Question

Ich versuche, eine ziemlich einfache Thread-Anwendung zu schreiben, aber bin neu in der Thread-Bibliothek boost. Ein einfaches Testprogramm arbeite ich an ist:

#include <iostream> 
#include <boost/thread.hpp> 

int result = 0; 
boost::mutex result_mutex; 

boost::thread_group g; 

void threaded_function(int i) 
{ 
    for(; i < 100000; ++i) {} 

    { 
     boost::mutex::scoped_lock lock(result_mutex); 
     result += i; 
    } 
} 

int main(int argc, char* argv[]) 
{ 
    using namespace std; 

    // launch three threads 
    boost::thread t1(threaded_function, 10); 
    boost::thread t2(threaded_function, 10); 
    boost::thread t3(threaded_function, 10); 

    g.add_thread(&t1); 
    g.add_thread(&t2); 
    g.add_thread(&t3); 

    // wait for them 
    g.join_all(); 

    cout << result << endl; 

    return 0; 
} 

Allerdings, wenn ich dieses Programm, das ich eine Ausgabe von

$ ./test 
300000 
test: pthread_mutex_lock.c:87: __pthread_mutex_lock: Assertion `mutex->__data.__owner == 0' failed. 
Aborted 

erhalten kompilieren und ausführen Offensichtlich ist das Ergebnis korrekt, aber ich mache mir Sorgen über diese Fehlermeldung, vor allem weil das echte Programm, das im Wesentlichen die gleiche Struktur hat, am Punkt join_all() hängen bleibt. Kann mir jemand erklären, was passiert? Gibt es eine bessere Möglichkeit, dies zu tun, d. H. Eine Anzahl von Threads zu starten, sie in einem externen Container zu speichern und dann darauf zu warten, dass sie alle abgeschlossen sind, bevor das Programm fortgesetzt wird?

Danke für Ihre Hilfe.

Answer 1

Ich denke, dass Ihr Problem durch den thread_group-Destruktor verursacht wird, der aufgerufen wird, wenn Ihr Programm beendet wird. Die Thread-Gruppe möchte die Zerstörung Ihrer Thread-Objekte übernehmen. Siehe auch in der boost::thread_group Dokumentation.

Sie erstellen Ihre Thread-Objekte im Stapel als lokale Variablen im Bereich Ihrer Hauptfunktion. Daher wurden sie bereits beim Beenden des Programms zerstört und thread_group versucht sie zu löschen.

Als Lösung erstellen Sie Ihre Thread-Objekte auf dem Heap mit neuen und lassen Sie die Pflege ihrer Zerstörung thread_group nehmen:

boost::thread *t1 = new boost::thread(threaded_function, 10); 
... 
g.add_thread(t1); 
... 

Answer 2

add_thread() übernimmt den Besitz des Threads, den Sie übergeben. Thread-Gruppe löscht den Thread. In diesem Beispiel löschen Sie den Speicher, der auf dem Stack zugewiesen wurde, sozusagen einen Kapitalverbrechen.

Mitgliedsfunktion add_thread()

Hohlraum add_thread (Gewinde * thrd);

Voraussetzung:

Der Ausdruck thrd löschen ist gut ausgebildet und wird in undefinierten Verhalten führen.

Effekte:

nehmen den boost :: Thread Objekt, auf das durch thrd und fügen Sie es an die Gruppe.

Nachbedingung:

this-> size() um eins erhöht.

Nicht sicher, ob das in Ihrem Code falsch ist oder ob dies nur ein Beispielfehler ist. Sonst sieht der Code gut aus.

Answer 3

Wenn Sie nicht brauchen, ein Handle auf Ihre Fäden, versuchen Sie es mit thread_group :: create_thread(), die die Notwendigkeit mildert den Faden überhaupt zu verwalten:

// Snip: Same as previous examples 

int main(int argc, char* argv[]) 
{ 
    using namespace std; 

    // launch three threads 
    for (int i = 0; i < 3; ++i) 
     g.create_thread(boost::bind(threaded_function, 10)); 

    // wait for them 
    g.join_all(); 

    cout << result << endl; 

    return 0; 
} 

Answer 4

Es sieht keine von oben tatsächlich die Frage beantwortet.

Ich traf das ähnliche Problem. Die Folge dieser Warnung (pthread_mutex_lock.c: 87: __pthread_mutex_lock. Assertion `Mutex -> _ Daten _owner == 0' ist fehlgeschlagen Abgebrochen.) Ist, dass manchmal die Programmthreads undicht wird und eine boost_resource_error Ausnahme verursachen.

Der Grund sieht aus wie das Programm weiterhin nach join_all() ausgeführt wird, obwohl die meisten Threads noch ausgeführt werden (nicht beendet).