Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

std::jthread — automatyczne dołączanie i kooperacyjne zatrzymywanie

std::jthread zarządza wątkiem i przy niszczeniu dołączalnego obiektu zgłasza żądanie zatrzymania, a następnie czeka na zakończenie. std::jthread::request_stop nie przerywa pracy siłowo: kod wątku musi współpracować, na przykład sprawdzając std::stop_token.

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

Składnia

#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 z nagłówka <thread> jest przenoszalnym, niekopiowalnym właścicielem wątku. Konstruktor sprawdza poprawność wywołania na podstawie typów obiektu wywoływalnego i argumentów po przekształceniu przez std::decay_t, a nie na podstawie pierwotnie przekazanych wyrażeń. Jeżeli std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> ma wartość true (gdzie F i Args... to dedukowane typy obiektu wywoływalnego i argumentów), konstruktor wybiera wywołanie z std::stop_token jako pierwszym argumentem. W przeciwnym razie wybiera wywołanie bez tokenu, które musi być poprawne dla typów po tym samym przekształceniu. Samo otrzymanie tokenu nie zapewnia obsługi zatrzymania.

std::jthread::request_stop() ma sygnaturę bool request_stop() noexcept. Zwraca true, gdy to wywołanie jako pierwsze zapisze żądanie we współdzielonym stanie zatrzymania; kolejne żądania zwracają false. Przy braku stanu zatrzymania również zwraca false. Wynik nie potwierdza zakończenia wątku. Zarejestrowane funkcje zwrotne zatrzymania są wykonywane synchronicznie podczas pierwszego skutecznego żądania.

Jeżeli joinable() zwraca true, destruktor wywołuje request_stop(), a potem join(). W odróżnieniu od std::thread nie wymaga więc ręcznego dołączenia przed zwykłym wyjściem z zakresu. Nie jest to jednak wymuszone anulowanie: ignorowanie tokenu lub zablokowana operacja może opóźnić zakończenie bez ograniczenia. Przechwycone referencje muszą pozostawać ważne aż do zakończenia wątku.

W przykładzie pierwsze żądanie daje true, drugie false. Destruktor czeka na zakończenie pracownika przed odczytem observed, więc ta zwykła zmienna bool nie wymaga tu atomowości. Pętla z yield() służy wyłącznie małej demonstracji aktywnego oczekiwania, nie jest wzorcem wydajnego oczekiwania. Tryb repozytorium to C++23; nie potwierdza to obsługi w środowisku produkcyjnym. Podany odnośnik prowadzi do rozwijanego szkicu standardu, nie do zamrożonego wydania C++23.

Przykłady

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

Wynik

true false true

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła