Einen boost :: thread für unbegrenzte Zeit anhalten

Question

Ich benutze die boost :: thread library (V1.44) um Threads in meinem C++ Projekt zu unterstützen.

Der Benutzer muss in der Lage sein, die Ausführung einer Testschleife, die in einem eigenen Thread ausgeführt wird, für eine unbegrenzte Zeit zu unterbrechen und in der Lage zu sein, es wann immer er will fortzusetzen.

unter Windows Ich löste es wie diese

bool ContintueLoop(){ 
if(testLoopPaused){ //testLoopPaused can be set by the user via GUI elements 
    try{ 
     boost::this_thread::interruptible_wait(2147483648); //that's very ugly, 
     // somebody knows the right way to pause it for a unlimited time? 
     return true; 
    } 
    catch(boost::thread_interrupted& e){ //when the user selects resume the 
     // the thread is interrupted and continues from here 
     testLoopPaused = false; 
     return true; 
    } 
if(...) //test for other flags like endTestLoop etc. 
    .... 
} 

Dies ohne Probleme funktioniert, obwohl es schön wäre, um den richtigen Wert für eine unbegrenzte Unterbrechung zu kennen.

begann ich eine Linux-Version meines Programms zu implementieren, aber ich lief in das Problem , dass ich den Compiler-Fehler

error: interruptible_wait is not a member of boost::this_thread

Frage bekommen: Was eine gute Möglichkeit ist, einen Schub zu pausieren :: thread für eine unbegrenzte Zeit (bis der Benutzer sie wieder aufnehmen entscheidet)

Vielen Dank

Answer 1

ich bin mir nicht bewusst keine Weise ein Gewinde an einem beliebigen Punkt mit boost :: thread zu pausieren, Die von Ihnen beschriebene Situation kann jedoch mithilfe einer booleschen, Mutex- und Bedingungsvariablen implementiert werden.

bool m_pause; // initialise to false in constructor! 
boost::mutex m_pause_mutex; 
boost::condition_variable m_pause_changed; 

void block_while_paused() 
{ 
    boost::unique_lock<boost::mutex> lock(m_pause_mutex); 
    while(m_pause) 
    { 
     m_pause_changed.wait(lock); 
    } 
} 

void set_paused(bool new_value) 
{ 
    { 
     boost::unique_lock<boost::mutex> lock(m_pause_mutex); 
     m_pause = new_value; 
    } 

    m_pause_changed.notify_all(); 
} 

in Ihrem Arbeitsthread So können Sie in regelmäßigen Abständen block_while_paused() aufrufen, die es wird bestätigt, bis m_pause auf false gesetzt ist. In Ihrem Hauptthread rufen Sie set_paused(value) auf, um den Wert der Pausenvariablen threadsicher zu aktualisieren.

Haftungsausschluss: Diese ist aus einem ähnlichen Code, den wir hier haben angepasst, aber ich habe nicht zu kompilieren, den angepassten Code versucht, geschweige denn überprüfen tatsächlich funktioniert :)

Answer 2

Wenn jemand muss noch erwähnt Funktionalität (Schlafgewinde bis ein Ereignis eintritt) und ist bequem mit Boost-Bibliotheken dann Boost.Interprocess Bibliothek bietet Semaphore Mechanismus, der wie beschrieben in Frage verwendet werden kann.