CKTIS / C++
std::jthread — junção automática e paragem cooperativa
std::jthread gere uma thread e, quando é destruído um objeto que ainda pode ser unido, solicita a paragem e depois aguarda a conclusão. std::jthread::request_stop não interrompe a execução à força: a thread tem de cooperar, por exemplo verificando um std::stop_token.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#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, declarado em <thread>, é um proprietário de thread movível e não copiável. O construtor verifica se a chamada é válida com base nos tipos do objeto invocável e dos argumentos após a transformação por std::decay_t, e não nas expressões originalmente fornecidas. Se std::is_invocable_v<std::decay_t<F>, std::stop_token, std::decay_t<Args>...> for true (em que F e Args... são os tipos deduzidos do objeto invocável e dos argumentos), o construtor escolhe a chamada com std::stop_token como primeiro argumento. Caso contrário, escolhe a chamada sem token, que tem de ser válida para os mesmos tipos transformados. Receber um token, por si só, não implementa a paragem.
std::jthread::request_stop() tem a assinatura bool request_stop() noexcept. Devolve true quando esta chamada regista pela primeira vez um pedido no estado de paragem partilhado; os pedidos seguintes devolvem false. Também devolve false quando não existe estado de paragem. O resultado não confirma que a thread tenha terminado. As funções de retorno de chamada de paragem registadas são executadas sincronamente durante o primeiro pedido bem-sucedido.
Se joinable() devolver true, o destrutor chama request_stop() e, em seguida, join(). Assim, ao contrário de std::thread, não é necessário efetuar uma junção manual antes de sair normalmente do âmbito. Isto não é um cancelamento forçado: ignorar o token ou permanecer numa operação bloqueante pode atrasar a conclusão indefinidamente. As referências capturadas têm de continuar válidas até a thread terminar.
No exemplo, o primeiro pedido produz true e o segundo false. O destrutor aguarda que a thread termine antes de observed ser lido, pelo que este bool normal não precisa de operações atómicas neste caso. O ciclo com yield() é apenas uma pequena demonstração de espera ativa, não um padrão de espera eficiente. O modo do repositório é C++23; isto não atesta o suporte do ambiente de execução em produção. A referência fornecida aponta para um projeto de norma em evolução, não para uma edição C++23 fixa.
Exemplos
#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';
}
Resultado
true false true
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.
Fontes
- 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)