Perché Boost scoped_lock non sblocca il mutex?

Question

Sto usando boost::mutex::scoped_lock in questo modo:

void ClassName::FunctionName() 
{ 
    { 
    boost::mutex::scoped_lock scopedLock(mutex_); 
    //do stuff 
     waitBoolean=true; 
    } 
    while(waitBoolean == true){ 
     sleep(1); 
    } 
    //get on with the thread's activities 
} 

Fondamentalmente imposta waitBoolean, e gli altri segnali di filo che viene fatto impostando waitBoolean false;

Questo non sembra funzionare, tuttavia, perché l'altro thread non può ottenere un blocco su mutex_ !!

Stavo partendo dal presupposto che avvolgendo il campo scoped_lock tra parentesi avrei chiuso il suo blocco. Questo non è il caso? La lettura online dice che rinuncia al mutex solo quando viene chiamato il distruttore. Non verrà distrutto quando uscirà dall'ambito locale?

Segnalazione parte di codice:

while(running_){ 
    boost::mutex::scoped_lock scopedLock(mutex_); 
    //Run some function that need to be done... 
    if(waitBoolean){ 
     waitBoolean=false; 
    } 
} 

Grazie!

Answer 1

Il campo scoped_lock deve essere effettivamente rilasciato alla fine dell'ambito. Tuttavia non blocchi il waitBoolean quando lo stai eseguendo, suggerendo di non proteggerlo correttamente anche in altri posti - ad es. dove è impostato su false e finirai con cattive condizioni di gara.

Direi che dovresti usare un boost :: condition_variable per fare questo genere di cose, invece del controllo sleep + thread-safe.

Answer 2

Per sincronizzare due thread utilizzare una variabile di condizione. Questo è lo stato del modo dell'arte per sincronizzare due thread nel modo desiderato:

Utilizzando spinta, la parte in attesa è qualcosa di simile:

void BoostSynchronisationPoint::waitSynchronisation() 
{ 
    boost::unique_lock<boost::mutex> lock(_mutex); 

    _synchronisationSent = false; 
    while(!_synchronisationSent) 
    { 
     _condition.wait(lock); // unlock and wait 
    } 
} 

Notifica parte è qualcosa di simile:

void BoostSynchronisationPoint::sendSynchronisation() 
{ 
    { 
     boost::lock_guard<boost::mutex> lock(_mutex); 
     _synchronisationSent = true; 
    } 

    _condition.notify_all(); 
} 

Il business con _synchronisationSent è quello di evitare wakeups spurie: vedi wikipedia

Answer 3

Inoltre vorrei suggerire di contrassegnare come volatile che waitBo Olean, comunque devi usare una condizione o anche meglio una barriera.