Timeout per thread.join()

Question

È possibile impostare un timeout per una chiamata a std::thread::join()? Voglio gestire il caso in cui il thread sta impiegando troppo tempo per essere eseguito, o terminare il thread. Potrei farlo per più thread (per esempio, fino a 30).

Preferibilmente senza boost, ma sarei interessato a una soluzione di boost se questo è il modo migliore.

Answer 1

Nessun timeout per std::thread::join(). Tuttavia, è possibile visualizzare std::thread::join() come funzione di semplice utilizzo. Usando condition_variable s puoi creare comunicazioni e cooperazioni molto ricche tra i tuoi thread, incluse le attese temporizzate. Ad esempio:

#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 questo esempio main lancia diversi thread turistiche lavoro, tutte occasionalmente controllano se è il momento di smettere sotto un mutex (potrebbe anche essere un atomico). Il thread principale controlla anche se è ora di uscire (se i thread ottengono tutto il loro lavoro). Se il principale esaurisce la pazienza, dichiara solo che è ora di uscire, quindi attende che tutti i thread eseguano le necessarie operazioni di pulizia prima di uscire.

Answer 2

Per Boost, vedere timed_join() per la versione di join() con timeout.

Answer 3

timed_join() è ora obsoleto. Utilizzare try_join_for() invece:

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

Answer 4

Invece di usare le discussioni in modo esplicito è possibile utilizzare std::async() per fornirvi un std::future<> e si può fare attese cronometrati sul std::future:

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

Answer 5

Sì, è possibile. La soluzione che è stata suggerita da Galik si presenta così:

#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. --- */ 

} 

Tuttavia, questo lancia essenzialmente un terzo filo che esegue la thread.join().

(Nota:. Il distruttore di future bloccherà fino thread è unito e il filo ausiliario ha terminato)

---

Forse lanciare un filo solo di portare un altro filo verso il basso non è ciò che si desidera. C'è un'altra soluzione portatile senza un filo ausiliario:

#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; 

dove T_return è il tipo di ritorno della routine thread. Questo scenario utilizza una combinazione std::future/std::async anziché std::thread.

Nota che hThread è un puntatore. Quando si chiama l'operatore delete, verrà richiamato il distruttore di *hThread e il blocco fino al termine del thread.

Ho testato entrambe le versioni con gcc 4.9.3 su Cygwin.