Timeout für thread.join()

Question

Kann ein Timeout für einen Anruf auf std::thread::join() festgelegt werden? Ich möchte den Fall behandeln, in dem der Thread zu lange dauert, oder den Thread beenden. Ich mache das vielleicht für mehrere Threads (sagen wir bis zu 30).

Vorzugsweise ohne Boost, aber ich wäre an einer Boost-Lösung interessiert, wenn das der beste Weg ist.

Answer 1

Es gibt keine Zeitüberschreitung für std::thread::join(). Sie können jedoch std::thread::join() nur als Komfortfunktion anzeigen. Mit condition_variable s können Sie eine sehr reichhaltige Kommunikation und Kooperation zwischen Ihren Threads erstellen, einschließlich zeitgesteuerter Wartezeiten. Zum Beispiel:

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

int thread_count = 0; 
bool time_to_quit = false; 
std::mutex m; 
std::condition_variable cv; 

void f(int id) 
{ 
    { 
    std::lock_guard<std::mutex> _(m); 
    ++thread_count; 
    } 
    while (true) 
    { 
     { 
     std::lock_guard<std::mutex> _(m); 
     std::cout << "thread " << id << " working\n"; 
     } 
     std::this_thread::sleep_for(std::chrono::milliseconds(250)); 
     std::lock_guard<std::mutex> _(m); 
     if (time_to_quit) 
      break; 
    } 
    std::lock_guard<std::mutex> _(m); 
    std::cout << "thread ended\n"; 
    --thread_count; 
    cv.notify_all(); 
} 

int main() 
{ 
    typedef std::chrono::steady_clock Clock; 
    std::thread(f, 1).detach(); 
    std::thread(f, 2).detach(); 
    std::thread(f, 3).detach(); 
    std::thread(f, 4).detach(); 
    std::thread(f, 5).detach(); 
    auto t0 = Clock::now(); 
    auto t1 = t0 + std::chrono::seconds(5); 
    std::unique_lock<std::mutex> lk(m); 
    while (!time_to_quit && Clock::now() < t1) 
     cv.wait_until(lk, t1); 
    time_to_quit = true; 
    std::cout << "main ending\n"; 
    while (thread_count > 0) 
     cv.wait(lk); 
    std::cout << "main ended\n"; 
} 

In diesem Beispiel main startet mehrere Threads zu tun, von denen alle gelegentlich überprüfen, ob es an der Zeit unter einem Mutex zu beenden ist (dies kann auch ein Atom sein könnte). Der Haupt-Thread überwacht auch, ob es Zeit ist, zu beenden (wenn die Threads ihre ganze Arbeit erledigen). Wenn main keine Geduld mehr hat, erklärt er einfach, dass es Zeit ist, zu beenden, und wartet dann darauf, dass alle Threads vor dem Beenden alle notwendigen Bereinigungen durchführen.

Answer 2

Für Boost, siehe timed_join() für die Version von Join() mit Timeout.

Answer 3

timed_join() ist jetzt veraltet. Verwenden Sie try_join_for() statt:

myThread.try_join_for(boost::chrono::milliseconds(8000)) 

Answer 4

Statt Threads explizit verwenden, können Sie std::async() verwenden, Sie mit einem std::future<> und Sie können sich auf der std::future timed wartet tun:

http://en.cppreference.com/w/cpp/thread/future/wait_for

Answer 5

Ja, es ist möglich. Die Lösung, die von Galik vorgeschlagen wurde, sieht wie folgt aus:

#include <thread> 
#include <future> 
... 
// Launch the thread. 
std::thread thread(ThreadFnc, ...); 
... 
// Terminate the thread. 
auto future = std::async(std::launch::async, &std::thread::join, &thread); 
if (future.wait_for(std::chrono::seconds(5)) 
    == std::future_status::timeout) { 

    /* --- Do something, if thread has not terminated within 5 s. --- */ 

} 

Dies ist jedoch im Wesentlichen einen dritten Thread startet, die die thread.join() ausführt.

. (Anmerkung: Der Destruktor von future wird blockiert, bis thread und der Hilfs Thread beendet hat beigetreten)

---

Vielleicht einen Thread startet gerade ist, einen anderen Thread bringen nicht das, was Sie wollen. Es gibt eine andere, tragbare Lösung ohne Hilfsgewinde:

#include <thread> 
#include <future> 
... 
// Launch the thread. 
std::future<T_return>* hThread 
    = new std::future<T_return>(std::async(std::launch::async, ThreadFnc, ...)); 
... 
// Terminate the thread. 
if (hThread->wait_for(std::chrono::seconds(5)) 
    == std::future_status::timeout) { 

    /* --- Do something, if thread has not terminated within 5 s. --- */ 

} else 
    delete hThread; 

wo T_return der Rückgabetyp der Threads Prozedur ist. In diesem Szenario wird eine std::future/std::async Kombination anstelle einer std::thread verwendet.

Beachten Sie, dass hThread ein Zeiger ist. Wenn Sie den Operator delete aufrufen, wird der Destruktor *hThread aufgerufen und blockiert, bis der Thread beendet ist.

Ich habe beide Versionen mit gcc 4.9.3 auf Cygwin getestet.