Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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