Comment vérifier efficacement si un `std::thread` est toujours en cours d'exécution en C ?

Comment vérifier si un std::thread est toujours en cours d'exécution (multiplateforme)

Lorsque vous travaillez avec std::thread, il est crucial de surveiller son exécution statut pour une gestion efficace des threads. Cependant, la méthode joinable() n'est pas conçue pour déterminer si un thread est toujours en cours d'exécution. Au lieu de cela, cet article présente diverses méthodes indépendantes de la plate-forme pour répondre à ce besoin.

Utilisation de std::async et std::future

Pour ceux qui sont à l'aise avec C 11, std::async et std ::future fournit une solution pratique. Avec std::future::wait_for(0ms), vous pouvez vérifier l'état du fil en examinant la valeur d'état renvoyée :

#include <future>
#include <thread>

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 << "Thread finished" << std::endl;
  } else {
    std::cout << "Thread still running" << std::endl;
  }

  auto result = future.get();
}

Utilisation de std::promise (avec std::thread)

Si std::async n'est pas une option, vous pouvez utiliser std::promise pour obtenir un futur object :

#include <future>
#include <thread>

int main() {
  std::promise<bool> 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 << "Thread finished" << std::endl;
  } else {
    std::cout << "Thread still running" << std::endl;
  }

  t.join();
}

Utilisation de std::atomic avec std::thread

Une approche simple pour C 11 et au-delà consiste à utiliser un indicateur atomique booléen :

#include <atomic>
#include <thread>

int main() {
  std::atomic<bool> done(false);

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

  // Check thread status
  if (done) {
    std::cout << "Thread finished" << std::endl;
  } else {
    std::cout << "Thread still running" << std::endl;
  }

  t.join();
}

Utilisation de std::packaged_task (avec std::thread)

Une autre option consiste à exploiter std::packaged_task, qui offre une alternative plus propre à l'utilisation std::promise:

#include <future>
#include <thread>

int main() {
  std::packaged_task<void()> task([] {
    std::this_thread::sleep_for(3s);
  });
  auto future = task.get_future();

  std::thread t(std::move(task));

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

  t.join();
}

Ces techniques vous permettent de surveiller efficacement l'état d'exécution de votre std::thread, garantissant une manipulation appropriée dans divers scénarios.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!