CKTIS / C++
std::stop_source — sorgente di richieste di arresto
std::stop_source fornisce uno stato condiviso per le richieste di arresto. get_token() permette di osservarlo, mentre request_stop() richiede l’arresto. È un meccanismo cooperativo: non interrompe automaticamente un thread in esecuzione.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <stop_token>
std::stop_source source;
std::stop_token token = source.get_token();
bool first_request = source.request_stop();
// Member signatures:
// std::stop_token get_token() const noexcept;
// bool request_stop() noexcept;std::stop_source, dichiarato nell’header <stop_token>, supporta l’arresto cooperativo. La costruzione predefinita crea un nuovo stato senza richieste di arresto; le copie della sorgente condividono tale stato. Il codice che svolge il lavoro deve controllare un token o usare un meccanismo che reagisca a una richiesta di arresto. La sorgente, da sola, non avvia né termina un thread.
std::stop_source::get_token() ha la firma std::stop_token get_token() const noexcept. Restituisce un token associato allo stato della sorgente. Il token può osservare le richieste tramite stop_requested(), ma non può richiedere l’arresto. Una sorgente costruita come std::stop_source{std::nostopstate} non ha uno stato: in tal caso, get_token() restituisce un token vuoto e request_stop() restituisce false.
std::stop_source::request_stop() ha la firma bool request_stop() noexcept. Richiede atomicamente il primo arresto per lo stato condiviso e restituisce true solo nella chiamata che ha effettuato la richiesta. Le chiamate successive restituiscono false; ciò non indica un errore né conferma che il lavoro sia terminato. Una richiesta non può essere annullata: per un nuovo ciclo serve un nuovo stato.
Le callback registrate vengono eseguite in modo sincrono alla prima richiesta, quindi request_stop() può eseguire codice dell’utente prima di restituire il controllo. Un’eccezione che esce da una callback causa std::terminate. L’esempio non crea intenzionalmente thread: mostra in modo deterministico la modifica dello stato osservata tramite il token.
Esempi
#include <iostream>
#include <stop_token>
int main() {
std::stop_source source;
const std::stop_token token = source.get_token();
std::cout << std::boolalpha;
std::cout << "before: " << token.stop_requested() << '\n';
const bool first = source.request_stop();
const bool second = source.request_stop();
std::cout << "requests: " << first << ' ' << second << '\n';
std::cout << "after: " << token.stop_requested() << '\n';
}
Risultato
before: false requests: true false after: 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.