WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::thread – einen Thread starten und seine Lebensdauer verwalten

std::thread führt eine aufrufbare Funktion in einem separaten Thread aus. Erfahre, worin sich joinable(), join() und detach() unterscheiden und warum die Verbindung zu einem Thread aufgehoben werden muss, bevor das zugehörige Objekt zerstört wird.

Version: C++23; repository compiler flag, production runtime not attested

Syntax

#include <thread>
std::thread t(callable);
bool active = t.joinable();
t.join();
// Alternative to join(): t.detach();

std::thread aus <thread> repräsentiert einen Ausführungs-Thread; sein Konstruktor mit einer aufrufbaren Funktion führt diese in einem neuen Thread aus. Das Objekt ist verschiebbar, aber nicht kopierbar. Die Standardkonstruktion startet keinen Thread. Dieser Eintrag behandelt die in C++23 verwendete API; die bereitgestellte Quelle ist ein fortlaufend bearbeiteter Entwurf und keine abgeschlossene C++23-Veröffentlichung.

std::thread::joinable() prüft, ob das Objekt noch einen Thread repräsentiert, nicht, ob dieser Thread noch läuft. Ein beendeter Thread bleibt joinable, bis join() oder detach() erfolgreich ausgeführt wurde. std::thread::join() wartet auf das Ende und synchronisiert dieses mit seiner erfolgreichen Rückkehr. Daher kann das Beispiel result nach join() ohne zusätzlichen Mutex lesen.

std::thread::detach() löst die Verbindung des Objekts zum Thread, ohne auf das Ende der Arbeit zu warten. Es beendet weder den Thread noch verlängert es die Lebensdauer erfasster Objekte: Referenzen auf lokale Variablen können ungültig werden. Nach einem erfolgreichen join() oder detach() gibt joinable() false zurück.

Die Zerstörung eines joinable-Objekts ruft std::terminate() auf, selbst wenn seine Arbeit bereits beendet ist. Sorge auch auf Ausnahmewegen für die Verwaltung der Lebensdauer; eine Ausnahme, die aus der Funktion des Threads entweicht, ruft ebenfalls std::terminate() auf. join() und detach() können std::system_error auslösen. Rufe sie nicht für ein nicht-joinable-Objekt auf und rufe join() nicht aus dem repräsentierten Thread heraus auf. Operationen am selben std::thread-Objekt werden nicht automatisch synchronisiert.

Beispiele

#include <iostream>
#include <thread>

int main() {
    int result = 0;
    std::thread worker([&result] { result = 42; });
    const bool before = worker.joinable();
    worker.join();
    std::cout << std::boolalpha
              << before << '\n'
              << worker.joinable() << '\n'
              << result << '\n';
}

Ergebnis

true
false
42

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen