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

CKTIS / C++

std::thread — iniciar uma thread e gerir o seu ciclo de vida

std::thread executa uma função invocável numa thread separada. Aprende as diferenças entre joinable(), join() e detach(), e porque é necessário resolver a associação à thread antes de destruir o objeto correspondente.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

#include <thread>
std::thread t(callable);
bool active = t.joinable();
t.join();
// Alternative to join(): t.detach();

std::thread, de <thread>, representa uma thread de execução; o seu construtor que recebe uma função invocável executa-a numa nova thread. O objeto pode ser movido, mas não copiado. A construção por omissão não inicia nenhuma thread. Esta entrada aborda a API usada em C++23; a fonte fornecida é um rascunho de trabalho em evolução, não uma publicação definitiva de C++23.

std::thread::joinable() verifica se o objeto ainda representa uma thread, não se essa thread continua em execução. Uma thread terminada continua joinable até que join() ou detach() seja concluído com êxito. std::thread::join() espera pelo fim e sincroniza essa conclusão com o seu retorno bem-sucedido. Assim, o exemplo pode ler result depois de join() sem um mutex adicional.

std::thread::detach() remove a associação do objeto à thread sem esperar que o trabalho termine. Não para a thread nem prolonga o tempo de vida dos objetos capturados: as referências a variáveis locais podem ficar pendentes. Depois de um join() ou detach() bem-sucedido, joinable() devolve false.

Destruir um objeto joinable chama std::terminate(), mesmo que o trabalho já tenha terminado. Gere o tempo de vida também nos percursos de exceção; uma exceção que escape da função da thread também chama std::terminate(). join() e detach() podem lançar std::system_error; não os chames num objeto não joinable nem chames join() a partir da thread representada. As operações sobre o mesmo objeto std::thread não são sincronizadas automaticamente.

Exemplos

#include <iostream>
#include <thread>

int main() {
    int result = 0;
    std::thread worker([&result] { result = 42; });
    const bool before = worker.joinable();
    worker.join();
    std::cout << std::boolalpha
              << before << '\n'
              << worker.joinable() << '\n'
              << result << '\n';
}

Resultado

true
false
42

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