Comment puis-je vérifier efficacement l'état d'exécution d'un std::thread en C ?

Vérification de l'état d'exécution d'un std::thread

Lors du développement d'applications multithread avec C , il devient souvent nécessaire de déterminer l'état d'exécution d'un std:: donné. fil de discussion. Cependant, std::thread ne dispose pas d'une méthode timed_join() pratique, et joinable() n'est spécifiquement pas destiné à cet effet.

La solution C 11

Si vous Si vous travaillez avec C 11, une solution élégante consiste à utiliser std::async et std::future. La fonction wait_for de std::future vous permet de vérifier l'état du fil de manière concise :

#include <future>
#include <thread>

auto future = std::async(std::launch::async, [] { ... }); // Run task on a new thread

// Check thread status with zero milliseconds wait time
auto status = future.wait_for(0ms);

if (status == std::future_status::ready)
    // Thread finished
else
    // Thread still running

Utilisation de std::promise

Pour std :: thread, vous pouvez tirer parti de std::promise pour obtenir un avenir object :

#include <future>
#include <thread>

std::promise<bool> p;
auto future = p.get_future();

std::thread t([&amp;p] { ...; p.set_value(true); }); // Run task on a new thread

// Get thread status using wait_for
auto status = future.wait_for(0ms);

Approche du drapeau atomique

Une autre option simple consiste à utiliser un drapeau atomique :

#include <thread>
#include <atomic>

std::atomic<bool> done(false);

std::thread t([&amp;done] { ...; done = true; }); // Run task with flag setting

if (done)
    // Thread finished
else
    // Thread still running

Std : :packaged_task

Pour une solution plus propre, pensez std::packaged_task :

#include <future>
#include <thread>

std::packaged_task<void()> task([] { ... });
auto future = task.get_future();

std::thread t(std::move(task)); // Run task on new thread

// Check thread status using wait_for
auto status = future.wait_for(0ms);

En utilisant ces approches, vous pouvez vérifier efficacement si un std::thread est toujours en cours d'exécution, garantissant ainsi un meilleur contrôle et une meilleure coordination dans vos applications multithread.

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!