WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

std::jthread – automatisches Beitreten und kooperatives Beenden

std::jthread verwaltet einen Thread und fordert beim Zerstören eines noch beitretbaren Objekts das Beenden an; anschließend wartet es auf den Abschluss. std::jthread::request_stop unterbricht die Ausführung nicht gewaltsam: Der Thread muss kooperieren, etwa indem er einen std::stop_token prüft.

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

Syntax

#include <thread>
#include <stop_token>

std::jthread worker([](std::stop_token token) {
    // Cooperatively observe token.stop_requested().
});
bool first_request = worker.request_stop();

std::jthread aus <thread> ist ein verschiebbarer, nicht kopierbarer Besitzer eines Threads. Der Konstruktor prüft die Aufrufbarkeit anhand der mit std::decay_t umgewandelten Typen des aufrufbaren Objekts und der Argumente, nicht anhand der ursprünglich übergebenen Ausdrücke. Ist std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> gleich true (wobei F und Args... die abgeleiteten Typen des aufrufbaren Objekts und der Argumente sind), wählt der Konstruktor den Aufruf mit std::stop_token als erstem Argument. Andernfalls wählt er den Aufruf ohne Token, der für dieselben umgewandelten Typen gültig sein muss. Ein Token zu erhalten bedeutet allein noch nicht, dass das Beenden unterstützt wird.

std::jthread::request_stop() hat die Signatur bool request_stop() noexcept. Der Aufruf gibt true zurück, wenn er erstmals eine Anforderung im gemeinsam genutzten Beendigungszustand vermerkt; nachfolgende Anforderungen geben false zurück. Ohne Beendigungszustand wird ebenfalls false zurückgegeben. Das Ergebnis bestätigt nicht, dass der Thread beendet ist. Registrierte Beendigungs-Callbacks werden während der ersten erfolgreichen Anforderung synchron ausgeführt.

Wenn joinable() true zurückgibt, ruft der Destruktor zuerst request_stop() und dann join() auf. Anders als bei std::thread ist daher vor dem gewöhnlichen Verlassen des Gültigkeitsbereichs kein manuelles Beitreten erforderlich. Das ist jedoch kein erzwungenes Abbrechen: Das Ignorieren des Tokens oder eine blockierende Operation kann den Abschluss unbegrenzt verzögern. Erfasste Referenzen müssen gültig bleiben, bis der Thread beendet ist.

Im Beispiel liefert die erste Anforderung true, die zweite false. Der Destruktor wartet auf den Thread, bevor observed gelesen wird; daher benötigt diese gewöhnliche bool-Variable hier keine atomaren Operationen. Die yield()-Schleife dient nur als kleines Beispiel für aktives Warten und ist kein effizientes Wartemuster. Der Repository-Modus ist C++23; das bestätigt keine Unterstützung zur Laufzeit in Produktionsumgebungen. Der angegebene Verweis führt zu einem fortlaufend bearbeiteten Standardentwurf, nicht zu einer festgeschriebenen C++23-Ausgabe.

Beispiele

#include <iostream>
#include <stop_token>
#include <thread>

int main() {
    bool observed = false;
    bool first = false;
    bool second = false;
    {
        std::jthread worker([&observed](std::stop_token token) {
            while (!token.stop_requested()) {
                std::this_thread::yield();
            }
            observed = true;
        });
        first = worker.request_stop();
        second = worker.request_stop();
    }
    std::cout << std::boolalpha
              << first << ' ' << second << ' ' << observed << '\n';
}

Ergebnis

true false true

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