Wie kann man effektiv überprüfen, ob ein „std::thread' in C noch läuft?

So überprüfen Sie, ob ein std::thread noch läuft (plattformübergreifend)

Bei der Arbeit mit std::thread ist es wichtig, seine Ausführung zu überwachen Status für eine effektive Thread-Verwaltung. Allerdings ist die Methode „joinable()“ nicht dazu gedacht, festzustellen, ob ein Thread noch läuft. Stattdessen stellt dieser Artikel verschiedene plattformunabhängige Methoden vor, um diesem Bedarf gerecht zu werden.

Verwendung von std::async und std::future

Für diejenigen, die mit C 11 vertraut sind: std::async und std ::future bietet eine komfortable Lösung. Mit std::future::wait_for(0ms) können Sie den Status des Threads überprüfen, indem Sie den zurückgegebenen Statuswert untersuchen:

#include <future>
#include <thread>

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 << "Thread finished" << std::endl;
  } else {
    std::cout << "Thread still running" << std::endl;
  }

  auto result = future.get();
}

Mit std::promise (mit std::thread)

Wenn std::async keine Option ist, können Sie std::promise verwenden, um eine Zukunft zu erhalten object:

#include <future>
#include <thread>

int main() {
  std::promise<bool> 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 << "Thread finished" << std::endl;
  } else {
    std::cout << "Thread still running" << std::endl;
  }

  t.join();
}

Using std::atomic mit std::thread

Ein einfacher Ansatz für C 11 und höher ist die Verwendung eines booleschen Atomflags:

#include <atomic>
#include <thread>

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

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

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

  t.join();
}

Verwendung von std::packaged_task (mit std::thread)

Eine weitere Option ist die Nutzung von std::packaged_task, was eine sauberere Alternative zur Verwendung bietet std::promise:

#include <future>
#include <thread>

int main() {
  std::packaged_task<void()> 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();
}

Mit diesen Techniken können Sie den Ausführungsstatus Ihres std::thread effizient überwachen und so die ordnungsgemäße Handhabung in verschiedenen Szenarien sicherstellen.

Das obige ist der detaillierte Inhalt vonWie kann man effektiv überprüfen, ob ein „std::thread' in C noch läuft?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!