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

Lorsque vous travaillez avec le thread std ::, il est crucial de surveiller son état d'exécution 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.

en utilisant std :: async et std :: futur

pour ceux qui sont confortables avec c 11, std :: async et std :: futur fournissent une solution pratique. Avec std :: futur :: wait_for (0ms), vous pouvez vérifier l'état du thread en examinant la valeur d'état renvoyée:

#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  
 Utilisation de std :: promesse (avec std :: thread) 
 
 Si std :: async n'est pas une option, vous pouvez utiliser std :: promesse d'obtenir un futur objet: 
 
#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  {
    std :: this_thread :: sleep_for (3s);
    p.set_value (true);
  });

  // Vérifiez l'état du thread
  auto status = future.wait_for (0ms);
  if (status == std :: future_status :: ready) {
    std :: cout   Utilisation de std :: atomic  avec std :: thread 
 
 Une approche simple pour C 11 et au-de
#include 

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

  std :: thread t (
#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  
 Utilisation de std :: packaged_task (avec std :: thread) 
 
 Une autre option consiste à tirer parti de std :: packaged_task, qui fournit une alternative plus propre à l'utilisation de std :: promesse: 
 
#include 
#include 

int main() {
  std::packaged_task 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 thread std ::, assurant une manipulation appropriée dans divers scénarios.