WaitForMultipleObjects Alternative mit Std :: Thread?

Question

Mein Problem ist, dass ich mehrere Threads habe, sie sind in einem Container gespeichert, und ich muss wissen, wann ein Thread an einer bestimmten Position beendet ist. Auf Fenster würde ich so etwas wie:

HANDLE handles[3]; 
//handles were initialized 
DWORD finishingThread = WaitForMultipleObjects(3, handles, false, INFINITE) 

Gibt es einen Weg, um die gleiche Wirkung mit std :: Thread zu erreichen?

Answer 1

Nach meinem besten Wissen gibt es nichts in der Standardbibliothek, das ein Warten dieser Art unterstützt. Die Standardbibliothek baut auf der zugrunde liegenden Betriebssystem-Threading-Unterstützung auf. Notfalls kann die Standardbibliothek nur die Funktionalität des kleinsten gemeinsamen Nenners bieten. Dies bedeutet, dass es nicht in der Lage ist, einige der umfangreicheren Funktionen der Win32-Threading-Bibliothek zu übernehmen.

Answer 2

Was Sie wollen, ist etwas, das Boost :: thread_group entspricht.

Gibt es nicht, aber Sie können diese Funktionalität schreiben: A std :: vector und std :: for_each, um join()/WaitForSingleObject für jedes Element aufzurufen oder natürlich nach einer dritten Partei zu suchen, die dasselbe tut cppthreadpool

Answer 3

Versuchen Sie Async++ Composition, die eine Referenzimplementierung für den C++ - Standardvorschlag N3428 ist.

Dieser Artikel ist relevant vor, dass:

Broken promises–C++0x futures

In einer unportable Weise können Sie auch std::thread::native_handle() nennen kann WaitForMultipleObjects mit der Rückkehr zu verwenden.

Answer 4

Verwenden Sie einfach eine std::condition_variable und lassen Sie Ihre Threads direkt vor dem Ende notify_all() oder notify_one() feuern.

Dann tun Sie cv.wait(), wo Sie Ihre WaitForMultipleObjects() aufrufen möchten.

Answer 5

Hier ist ein Beispiel dafür, wie man die gleiche Wirkung erzielen kann mit std::thread und std::future, wenn Sie bereit sind, den Haupt-Thread schlafen zu lassen, während Polling die Bereitschaft der Fäden (alternativ Sie ein dedizierter Thread die Warte behandeln lassen konnte).

diese Funktion Betrachten wir eine Reihe von Iteratoren in einen Behälter mit std::future nehmen, die bis zumindest eine Aufgabe beendet ist blockiert:

const int TIME_BETWEEN_POLLS_MS = 50; 

// Wait (sleep) between polls until a task is finished then return iterator to future. 
template <typename Iterator> 
Iterator waitForFirst(Iterator first, Iterator last) { 
    auto it = first; 
    auto status = std::future_status::timeout; 
    while (status != std::future_status::ready) { 
     if (++it == last) { // Rotate in range. 
      it = first; 
     } 
     status = it->wait_for(std::chrono::milliseconds(TIME_BETWEEN_POLLS_MS)); 
    } 
    return it; 
} 

Nun, wenn Sie einen Container von Futures (std::future) haben Mit den Rückgabewerten Ihrer Aufgaben, die auf separaten Threads ausgeführt werden, können Sie einfach die Funktion waitForFirst verwenden, um einen Iterator für die Zukunft zu erhalten, der sein Ergebnis zuerst erhält.

// Lets say you have a vector of futures, e.g. 
    std::vector<std::future<std::thread::id>> futures; 

    /* Push futures to vector... */ 

    // Block until first task is finished. 
    // 'it' is iterator to future associated with result. 
    auto it = finishingThread(std::begin(futures), std::end(futures)); 

Siehe live example