KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::jthread — automatisch joinen en coöperatief stoppen

std::jthread beheert een thread en vraagt bij vernietiging van een object waarop nog een join mogelijk is om te stoppen; daarna wacht het op voltooiing. std::jthread::request_stop onderbreekt de uitvoering niet met geweld: de thread moet meewerken, bijvoorbeeld door een std::stop_token te controleren.

Versie: 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, gedeclareerd in <thread>, is een verplaatsbare, niet-kopieerbare eigenaar van een thread. De constructor controleert of de aanroep geldig is aan de hand van de types van het aanroepbare object en de argumenten na toepassing van std::decay_t, niet aan de hand van de oorspronkelijk opgegeven expressies. Als std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> true is (waarbij F en Args... de afgeleide types van het aanroepbare object en de argumenten zijn), kiest de constructor de aanroep met std::stop_token als eerste argument. Anders kiest hij de aanroep zonder token, die geldig moet zijn voor dezelfde getransformeerde types. Alleen een token ontvangen zorgt nog niet voor ondersteuning van stoppen.

std::jthread::request_stop() heeft de signatuur bool request_stop() noexcept. De functie geeft true terug wanneer deze aanroep voor het eerst een verzoek vastlegt in de gedeelde stopstatus; volgende verzoeken geven false terug. Zonder stopstatus geeft de functie ook false terug. Het resultaat bevestigt niet dat de thread is beëindigd. Geregistreerde stop-callbacks worden synchroon uitgevoerd tijdens het eerste geslaagde verzoek.

Als joinable() true teruggeeft, roept de destructor eerst request_stop() en daarna join() aan. In tegenstelling tot std::thread is handmatig joinen dus niet nodig voordat de scope normaal wordt verlaten. Dit is echter geen geforceerde annulering: het negeren van het token of blijven hangen in een blokkerende bewerking kan de voltooiing onbeperkt vertragen. Vastgelegde verwijzingen moeten geldig blijven totdat de thread klaar is.

In het voorbeeld levert het eerste verzoek true op en het tweede false. De destructor wacht tot de thread klaar is voordat observed wordt gelezen; deze gewone bool heeft hier dus geen atomaire bewerkingen nodig. De yield()-lus is alleen een kleine demonstratie van actief wachten en geen efficiënt wachtpatroon. De repositorymodus is C++23; dit bevestigt geen ondersteuning in productieomgevingen tijdens uitvoering. De opgegeven verwijzing leidt naar een zich ontwikkelend normontwerp, niet naar een definitieve C++23-editie.

Voorbeelden

#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';
}

Resultaat

true false true

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen