Como verificar se um thread std :: ainda está em execução (cruzado)

ao trabalhar com std :: thread, é crucial monitorar seu status de execução para gerenciamento de encadeamento eficaz. No entanto, o método junção () não foi projetado para determinar se um thread ainda está em execução. Em vez disso, este artigo apresenta vários métodos independentes da plataforma para atender a essa necessidade. Com std :: Future :: wait_for (0ms), você pode verificar o status do tópico examinando o valor de status retornado:

#incluir #include int main () { Auto Future = STD :: Async (STD :: Launch :: Async, [] { std :: this_thread :: sleep_for (3s); retornar 8; }); // Verifique o status do thread status automático = futuro.wait_for (0ms); if (status == std :: Future_Status :: Ready) { std :: cout

usando std :: promey (com std :: thread)

#include 
#include 

int main() {
  auto future = std::async(std::launch::async, [] {
    std::this_thread::sleep_for(3s);
    return 8;
  });

  // Check thread status
  auto status = future.wait_for(0ms);
  if (status == std::future_status::ready) {
    std::cout  
#incluir 
#include 

int main () {
  std :: PROMECTION  p;
  Auto futuro = p.get_future ();

  std :: thread t (
 {
    std :: this_thread :: sleep_for (3s);
    p.set_value (true);
  });

  // Verifique o status do thread
  status automático = futuro.wait_for (0ms);
  if (status == std :: Future_Status :: Ready) {
    std :: cout   usando std :: atomic  com std :: thread 
#include 
#include 

int main() {
  std::promise p;
  auto future = p.get_future();

  std::thread t([&p] {
    std::this_thread::sleep_for(3s);
    p.set_value(true);
  });

  // Check thread status
  auto status = future.wait_for(0ms);
  if (status == std::future_status::ready) {
    std::cout  uma abordagem direta para C 11 e além é utilizar uma bandeira atômica booleana: 
 
#incluir 
#include 

int main () {
  std :: Atomic  feito (false);

  std :: thread t (
 {
    std :: this_thread :: sleep_for (3s);
    feito = true;
  });

  // Verifique o status do thread
  se (feito) {
    std :: cout  
#include 
#include 

int main() {
  std::atomic done(false);

  std::thread t([&done] {
    std::this_thread::sleep_for(3s);
    done = true;
  });

  // Check thread status
  if (done) {
    std::cout  
 outra opção é aproveitar o std :: packaged_task, que fornece uma alternativa mais limpa ao uso de std :: promete:
#include 

int main () {
  std :: packaged_task  tarefa ([] {
    std :: this_thread :: sleep_for (3s);
  });
  Auto Future = Task.get_future ();

  std :: thread t (std :: mover (tarefa));

  // Verifique o status do thread
  status automático = futuro.wait_for (0ms);
  if (status == std :: Future_Status :: Ready) {
    // ...
  }

  T.Join ();
} 
 
 Essas técnicas permitem monitorar com eficiência o status de execução do seu thread STD ::, garantindo manuseio adequado em vários cenários.