Come posso sapere in modo affidabile se un thread di boost è uscito dal suo metodo di esecuzione?

Question

Supponevo che fosse possibile indicarlo, tuttavia, non sembra essere il caso.

In una classe lavoratrice, stavo cercando di indicare che era ancora in fase di elaborazione attraverso un predicato:

bool isRunning(){return thread_->joinable();} 

Non sarebbe un filo che è uscito non essere joinable? Cosa mi manca ... qual è il significato di boost thread :: joinable?

Answer 1

Poiché è possibile partecipare a un thread anche dopo la sua chiusura, joinable() restituirà true finché non si chiama join() o detach(). Se vuoi sapere se un thread è ancora in esecuzione, dovresti essere in grado di chiamare timed_join con un tempo di attesa pari a 0. Nota che questo può causare una condizione di competizione poiché il thread potrebbe terminare subito dopo la chiamata.

Answer 2

Fondamentalmente non è possibile farlo. La ragione è che le due risposte possibili sono "Sì" e "Non quando ho guardato l'ultima volta ma forse ora". Non esiste un modo affidabile per determinare se un thread è ancora all'interno del suo metodo di esecuzione, anche se esistesse un modo affidabile per determinare l'opposto.

Answer 3

Utilizzare thread::timed_join() con un timeout minimo. Restituirà false se il thread è ancora in esecuzione.

Answer 4

Sto utilizzando boost 1.54, in base al quale lo stage timed_join() è in fase di deprecazione. A seconda del vostro uso, è possibile utilizzare unibili(), che funziona perfettamente per i miei scopi, o, in alternativa è possibile utilizzare try_join_for() o try_join_until(), vedi:

http://www.boost.org/doc/libs/1_54_0/doc/html/thread/thread_management.html

Answer 5

Questo è un po 'grezzo, ma come di ora funziona ancora per le mie esigenze. :) Sto usando boost 153 e qt. Ho creato un vettore di int per tracciare lo "stato" dei miei thread. Ogni volta che creo un nuovo thread, aggiungo una voce a thread_ids con un valore pari a 0. Per ogni thread creato, trasmetto un ID in modo da sapere quale parte di thread_ids devo aggiornare. Imposta lo stato su 1 per l'esecuzione e altri valori in base all'attività che sto svolgendo, quindi so quale attività è stata eseguita al termine del thread. 100 è il valore che ho impostato per un thread correttamente finito. Non sono sicuro che ciò possa essere d'aiuto, ma se hai altri suggerimenti su come migliorare su questo fammelo sapere. :)

std::vector<int> thread_ids; 
const int max_threads = 4; 
void Thread01(int n, int n2) 
{ 
    thread_ids.at(n) = 1; 
    boost::this_thread::sleep(boost::posix_time::milliseconds(n2 * 1000)); 
    thread_ids.at(n) = 100; 
    qDebug()<<"Done "<<n; 

} 
void getThreadsStatus() 
{ 
    qDebug()<<"status:"; 
    for(int i = 0; i < max_threads, i < thread_ids.size(); i++) 
    { 
     qDebug()<<thread_ids.at(i); 
    } 
} 
int main(int argc, char *argv[]) 
{ 
    for(int i = 0; i < max_threads; i++) 
    { 
     thread_ids.push_back(0); 
     threadpool.create_thread(
      boost::bind(&boost::asio::io_service::run, &ioService)); 
     ioService.post(boost::bind(Thread01, i, i + 2)); 
     getThreadsStatus(); 
    } 

    ioService.stop(); 
    threadpool.join_all(); 
    getThreadsStatus(); 
} 

Answer 6

Il modo più semplice, se la funzione che esegue il thread è abbastanza semplice, è impostare una variabile su true al termine della funzione. Naturalmente, avrai bisogno di una variabile per thread, se hai molti una mappa di ID di thread e lo stato può essere un'opzione migliore. So che è fatto a mano, ma nel frattempo funziona bene.

class ThreadCreator 
{ 
private: 
    bool   m_threadFinished; 
    void launchProducerThread(){ 
     // do stuff here 
     m_threadRunning = true; 
    } 
public: 
    ThreadCreator() : m_threadFinished(false) { 
     boost::thread(&Consumer::launchProducerThread, this); 
    } 
}; 

Answer 7

Questo non può essere una risposta diretta alla sua domanda, ma vedere il concetto filo come meccanismo realmente leggero e volutamente privo di qualsiasi cosa tranne meccanismi di sincronizzazione. Penso che il posto giusto per mettere "sia in esecuzione" sia nella classe che definisce la funzione thread. Si noti che dal punto di vista del design, è possibile uscire dal thread su interrupt e non completare il lavoro. Se vuoi ripulire il thread una volta completato, puoi inserirlo in un puntatore sicuro e passarlo alla classe worker.