wie man prüft, ob ein std :: thread noch ausgeführt wird (plattformübergreifend)

Bei der Arbeit mit std :: thread ist es von entscheidender Bedeutung, den Ausführungsstatus für eine effektive Thread-Verwaltung zu überwachen. Die Joinable () -Methode ist jedoch nicht dafür ausgelegt, ob noch ein Thread ausgeführt wird. Stattdessen enthält dieser Artikel verschiedene plattformunabhängige Methoden, um dieses Bedürfnis zu befriedigen.

mit std :: async und std :: future

für diejenigen, die mit c 11, std :: async und std :: future eine bequeme Lösung bieten. Mit std :: Future :: wait_for (0ms) können Sie den Status des Threads überprüfen, indem Sie den zurückgegebenen Statuswert untersuchen:

#include 
#include 

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  
 mit std :: verspricht (mit std :: thread) 
 
 Wenn std :: async keine Option ist, können Sie std :: versprechen, ein zukünftiges Objekt zu erhalten: 
 
#include 
#include 

int main() {
  std::promise 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  {
    std :: this_thread :: sleep_for (3s);
    P.Set_Value (true);
  });

  // Thread -Status überprüfen
  Auto status = Future.wait_for (0 ms);
  if (Status == std :: Future_status :: Ready) {
    std :: cout   mit std :: atomic  mit std :: thread 
 
 Ein direkter Ansatz für C 11 und darüber hinaus ist es, eine booleale atomische Flagge zu verwenden: 
#include 
#include 

int main() {
  std::atomic done(false);

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

  // Check thread status
  if (done) {
    std::cout #
#include 

int main () {
  std :: atomic  mone (falsch);

  std :: thread t (
 {
    std :: this_thread :: sleep_for (3s);
    fertig = wahr;
  });

  // Thread -Status überprüfen
  if (fertig) {
    std :: cout  
 mit std :: packaged_task (mit std :: thread) 
 
#include 
#include 

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

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

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

  // Thread -Status überprüfen
  Auto status = Future.wait_for (0 ms);
  if (Status == std :: Future_status :: Ready) {
    // ...
  }

  T.Join ();
} 
 
 Diese Techniken ermöglichen es Ihnen, den Ausführungsstatus Ihres std :: thread effizient zu überwachen und in verschiedenen Szenarien eine ordnungsgemäße Handhabung sicherzustellen.