Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::jthread — join automatico e arresto cooperativo

std::jthread gestisce un thread e, quando viene distrutto un oggetto che può ancora essere unito, richiede l’arresto e poi attende il completamento. std::jthread::request_stop non interrompe forzatamente l’esecuzione: il thread deve collaborare, per esempio controllando uno std::stop_token.

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

Sintassi

#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, dichiarato in <thread>, è un proprietario di thread spostabile e non copiabile. Il costruttore verifica se la chiamata è valida usando i tipi dell’oggetto invocabile e degli argomenti dopo la trasformazione con std::decay_t, non le espressioni fornite in origine. Se std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> vale true (dove F e Args... sono i tipi dedotti dell’oggetto invocabile e degli argomenti), il costruttore sceglie la chiamata con std::stop_token come primo argomento. Altrimenti sceglie la chiamata senza token, che deve essere valida per gli stessi tipi trasformati. Ricevere un token, da solo, non implementa l’arresto.

std::jthread::request_stop() ha la firma bool request_stop() noexcept. Restituisce true quando questa chiamata registra per la prima volta una richiesta nello stato di arresto condiviso; le richieste successive restituiscono false. Restituisce false anche quando non è presente uno stato di arresto. Il risultato non conferma che il thread sia terminato. Le funzioni di callback di arresto registrate vengono eseguite sincronicamente durante la prima richiesta riuscita.

Se joinable() restituisce true, il distruttore chiama request_stop() e poi join(). A differenza di std::thread, quindi, non è necessario eseguire un join manuale prima della normale uscita dall’ambito. Questo non equivale a un annullamento forzato: ignorare il token o rimanere in un’operazione bloccante può ritardare il completamento indefinitamente. I riferimenti acquisiti devono restare validi fino alla conclusione del thread.

Nell’esempio, la prima richiesta produce true e la seconda false. Il distruttore attende la conclusione del thread prima che venga letto observed, quindi questo normale bool non richiede operazioni atomiche in questo caso. Il ciclo con yield() è solo una breve dimostrazione di attesa attiva, non un modello efficiente di attesa. La modalità del repository è C++23; ciò non attesta il supporto dell’ambiente di esecuzione in produzione. Il riferimento fornito punta a una bozza di standard in evoluzione, non a un’edizione C++23 definitiva.

Esempi

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

Risultato

true false true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti