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
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Constructors, move, and assignment [thread.jthread.cons]
- C++ working draft — Stop token handling [thread.jthread.stop]
- C++ working draft — Member functions [stopsource.mem]
- C++ working draft — Stop token concepts [stoptoken.concepts]
- C++ working draft — Member functions [thread.jthread.mem] (unofficial HTML rendering)