Wie kann ich den Status eines laufenden std::thread in C effizient überprüfen?

Überprüfen des Status eines laufenden std::thread

In C ist std::thread eine Art Klasse zur Implementierung der Parallelität. Es kann schwierig sein, festzustellen, ob ein std::thread noch läuft, insbesondere wenn die Plattformunabhängigkeit von entscheidender Bedeutung ist.

Ursprünglich fehlte std::thread eine timed_join()-Methode, und joinable() war nicht dafür gedacht diesen Zweck. Es wird eine alternative Lösung vorgeschlagen, die std::lock_guard verwendet, um einen Mutex innerhalb des Threads zu sperren, und dann die Methode try_lock() verwendet, um zu beurteilen, ob er noch gesperrt ist, was den Ausführungsstatus des Threads anzeigt. Diese Strategie wird jedoch als unnötig komplex angesehen.

Elegante Lösungen zur Überprüfung des Thread-Status

Für einen saubereren Ansatz sollten Sie die Nutzung von std::async und std::future in Betracht ziehen. std::async ermöglicht asynchrone Aufgaben in einem separaten Thread und std::future ermöglicht das Abrufen der Ergebnisse des Vorgangs. Die Funktion „wait_for“ von std::future kann mit einem Timeout von null Millisekunden verwendet werden, um effektiv zu überprüfen, ob der Thread noch läuft:

#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.
}

Alternativ kann man std::promise verwenden, um ein zukünftiges Objekt abzurufen 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.
}

In beiden Beispielen wird zunächst „Thread läuft noch“ angezeigt, da der Status überprüft wird, bevor der Thread abgeschlossen ist. Eine noch einfachere Lösung besteht jedoch darin, ein atomares boolesches Flag zu verwenden:

#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.
}

Das obige ist der detaillierte Inhalt vonWie kann ich den Status eines laufenden std::thread in C effizient überprüfen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!