Wann sollte ich std :: thread :: remove verwenden?

Manchmal muss ich std::threadmeine Anwendung beschleunigen. Ich weiß auchjoin() wartet, bis ein Thread abgeschlossen ist. Das ist leicht zu verstehen, aber was ist der Unterschied zwischen Anrufen detach()und Nichtanrufen?

Ich dachte das ohne detach() , die Methode des Threads mit einem Thread unabhängig arbeiten wird.

Nicht ablösen:

void Someclass::Somefunction() {
    //...

    std::thread t([ ] {
        printf("thread called without detach");
    });

    //some code here
}

Anrufen mit Abnehmen:

void Someclass::Somefunction() {
    //...

    std::thread t([ ] {
        printf("thread called with detach");
    });

    t.detach();

    //some code here
}

Im Destruktor std::thread, std::terminatewird aufgerufen , wenn:

• Der Thread wurde nicht verbunden (mit t.join())
• und wurde auch nicht losgelöst (mit t.detach())

Daher sollten Sie immer entweder joinoder detacheinen Thread verwenden, bevor die Ausführungsflüsse den Destruktor erreichen.

Wenn ein Programm beendet wird (dh main zurückkehrt), wird nicht auf die verbleibenden getrennten Threads gewartet, die im Hintergrund ausgeführt werden. Stattdessen wird ihre Ausführung angehalten und ihre threadlokalen Objekte zerstört.

Entscheidend ist, dass der Stapel dieser Threads nicht abgewickelt wird und daher einige Destruktoren nicht ausgeführt werden. Abhängig von den Aktionen, die diese Destruktoren ausführen sollten, kann dies eine so schlimme Situation sein, als ob das Programm abgestürzt oder getötet worden wäre. Hoffentlich hebt das Betriebssystem die Sperren für Dateien usw. auf, aber Sie könnten den gemeinsam genutzten Speicher, halbgeschriebene Dateien und dergleichen beschädigt haben.

Also, solltest du joinoder verwenden detach?

• Verwenden join
• Sofern Sie mehr Flexibilität haben müssen , und sind bereit , einen Synchronisationsmechanismus zu schaffen , für den Thread Abschluss warten auf eigene Faust , in diesem Fall können Sie verwendendetach

Sie sollten anrufen, detachwenn Sie nicht auf den Abschluss des Threads warten möchten, joinsondern der Thread stattdessen nur so lange ausgeführt wird, bis er fertig ist, und dann beenden, ohne dass der Haupt-Thread speziell darauf wartet.

detachGrundsätzlich werden die Ressourcen freigegeben, die für die Implementierung erforderlich sind join.

Es ist ein schwerwiegender Fehler , wenn ein Thread - Objekt sein Leben endet und weder joinnoch detachgenannt wurde; in diesem Fall terminatewird aufgerufen.

Wenn Sie den Thread trennen, bedeutet dies, dass Sie dies nicht müssen join() ihn vor dem Beendenmain() .

Die Thread-Bibliothek wartet tatsächlich auf jeden solchen Thread unter main , aber Sie sollten sich nicht darum kümmern.

detach()Dies ist vor allem dann nützlich, wenn Sie eine Aufgabe haben, die im Hintergrund ausgeführt werden muss, deren Ausführung Ihnen jedoch egal ist. Dies ist normalerweise bei einigen Bibliotheken der Fall. Möglicherweise erstellen sie stillschweigend einen Hintergrund-Worker-Thread und trennen ihn, sodass Sie ihn nicht einmal bemerken.

Diese Antwort zielt darauf ab, die Frage im Titel zu beantworten, anstatt den Unterschied zwischen joinund zu erklären detach. Also wann solltestd::thread::detach sollte es verwendet werden?

In ordnungsgemäß gepflegtem C ++ std::thread::detachsollte Code überhaupt nicht verwendet werden. Der Programmierer muss sicherstellen, dass alle erstellten Threads ordnungsgemäß beendet werden, um alle erfassten Ressourcen freizugeben und andere erforderliche Bereinigungsaktionen auszuführen. Dies bedeutet, dass das Aufgeben des Eigentums an Threads durch Aufrufen detachkeine Option ist und daher joinin allen Szenarien verwendet werden sollte.

Einige Anwendungen basieren jedoch auf alten und oft nicht gut gestalteten und unterstützten APIs, die möglicherweise unbegrenzt blockierende Funktionen enthalten. Das Verschieben von Aufrufen dieser Funktionen in einen dedizierten Thread, um das Blockieren anderer Inhalte zu vermeiden, ist eine gängige Praxis. Es gibt keine Möglichkeit, einen solchen Thread ordnungsgemäß zu beenden, sodass die Verwendung von joinnur zum Blockieren des primären Threads führt. Dies ist eine Situation, in der die Verwendung detacheine weniger böse Alternative wäre, um beispielsweise ein threadObjekt mit dynamischer Speicherdauer zuzuweisen und es dann absichtlich zu verlieren.

#include <LegacyApi.hpp>
#include <thread>

auto LegacyApiThreadEntry(void)
{
    auto result{NastyBlockingFunction()};
    // do something...
}

int main()
{
    ::std::thread legacy_api_thread{&LegacyApiThreadEntry};
    // do something...
    legacy_api_thread.detach();
    return 0;
}

Laut cppreference.com :

Trennt den Ausführungsthread vom Thread-Objekt, sodass die Ausführung unabhängig fortgesetzt werden kann. Alle zugewiesenen Ressourcen werden freigegeben, sobald der Thread beendet wird.

Nach dem Aufruf *thisbesitzt remove keinen Thread mehr.

Beispielsweise:

  std::thread my_thread([&](){XXXX});
  my_thread.detach();

Beachten Sie die lokale Variable: my_threadWährend die Lebensdauer von abgelaufen my_threadist, wird der Destruktor von std::threadaufgerufen und std::terminate()innerhalb des Destruktors aufgerufen.

Aber wenn Sie verwenden detach(), sollten Sie nicht my_threadmehr verwenden, auch wenn die Lebensdauer von abgelaufen my_threadist, wird dem neuen Thread nichts passieren.