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

Vérification d'un std::Thread actif

Dans le domaine du multithreading, comprendre si un std::thread est toujours en cours d'exécution reste crucial . Cet article aborde les techniques pratiques de vérification de l'état des threads indépendantes de la plate-forme.

Utilisation de std::async et std::future

Exploitation de std::async et std : :future offre une approche transparente pour surveiller l’état des threads. L'utilisation de wait_for() sur le futur objet fournit un aperçu immédiat de l'état du thread :

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

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

    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;
    }
}

Utilisation de std::promise et std::future

Une solution alternative implique de tirer parti de std::promise et std::future:

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

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

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

    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

Une approche plus simple utilise std::atomic:

#include <thread>
#include <atomic>
#include <chrono>
#include <iostream>

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

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

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

    t.join();
}

Utilisation de std::packaged_task

En conjonction avec std::thread, std::packaged_task propose une solution plus raffinée :

#include <future>
#include <thread>
#include <chrono>
#include <iostream>

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

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

    auto status = future.wait_for(0ms);

    if (status == std::future_status::ready) {
        // ...
    }

    t.join();
}

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!