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

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

En C , std::thread est un type de classe pour implémenter la concurrence. Il peut être difficile de déterminer si un std::thread est toujours en cours d'exécution, surtout si l'indépendance de la plate-forme est cruciale.

À l'origine, std::thread ne disposait pas d'une méthode timed_join() et joinable() n'était pas destiné à ce but. Une solution alternative est proposée qui utilise std::lock_guard pour verrouiller un mutex dans le thread, puis utilise la méthode try_lock() pour évaluer s'il est toujours verrouillé, indiquant l'état d'exécution du thread. Cependant, cette stratégie est considérée comme inutilement complexe.

Solutions élégantes pour vérifier l'état des fils

Pour une approche plus propre, envisagez de tirer parti de std::async et std::future. std::async active les tâches asynchrones sur un thread séparé et std::future permet de récupérer les résultats de l'opération. La fonction wait_for de std::future peut être utilisée avec un délai d'attente de zéro milliseconde pour vérifier efficacement si le thread est toujours en cours d'exécution :

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

int main() {
    // Create an asynchronous task on a new thread using std::async.
    auto future = std::async(std::launch::async, [] {
        std::this_thread::sleep_for(3s);
        return 8;
    });

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

    // Print status according to the wait_for() result.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    auto result = future.get(); // Retrieve result.
}

Alternativement, on peut utiliser std::promise pour obtenir un futur objet à partir de a std::thread:

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

int main() {
    // Create a promise and its associated future.
    std::promise<bool> p;
    auto future = p.get_future();

    // Run a task on a new thread using std::thread.
    std::thread t([&amp;p] {
        std::this_thread::sleep_for(3s);
        p.set_value(true); // Set the promise value atomically.
    });

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

    // Print status according to the wait_for() result.
    if (status == std::future_status::ready) {
        std::cout << "Thread finished" << std::endl;
    } else {
        std::cout << "Thread still running" << std::endl;
    }

    t.join(); // Join the thread.
}

Les deux exemples afficheront initialement "Thread toujours en cours d'exécution" car l'état est vérifié avant la fin du thread. Cependant, une solution encore plus simple consiste à utiliser un indicateur booléen atomique :

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

int main() {
    // Use an atomic boolean flag for thread status tracking.
    std::atomic<bool> done(false);

    // Run a task on a new thread that sets `done` to true when finished.
    std::thread t([&amp;done] {
        std::this_thread::sleep_for(3s);
        done = true;
    });

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

    t.join(); // Join the thread.
}

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!