¿Por qué Boost scoped_lock no desbloquea el mutex?

Question

He estado usando boost::mutex::scoped_lock de esta manera:

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 
} 

Básicamente se establece waitBoolean, y las otras señales de hilo que se hace estableciendo waitBoolean en false;

Esto no parece funcionar, sin embargo, porque el otro hilo no puede obtener un bloqueo en mutex_ !!

Estaba asumiendo que al ajustar el scoped_lock entre paréntesis terminaría su bloqueo. Este no es el caso? La lectura en línea dice que solo abandona el mutex cuando se llama al destructor. ¿No será destruido cuando salga del alcance local?

señalización de la parte de código:

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

Gracias!

Answer 1

El scoped_lock debería liberarse al final del alcance. Sin embargo, no bloquea el waitBoolean cuando lo está bucleando, lo que sugiere que no lo protege adecuadamente en otros lugares también, como p. donde está establecido en falso, y terminarás con condiciones desagradables de carrera.

Yo diría que debería usar un boost :: condition_variable para hacer este tipo de cosas, en lugar de sleep + comprobación de hilos inseguros.

Answer 2

Para sincronizar dos hilos, use una variable de condición. Ese es el estado de la forma en el arte para sincronizar dos hilos de la forma que desee:

Usando impulso, la parte de espera es algo así como:

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

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

El notificar parte es algo así como:

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

    _condition.notify_all(); 
} 

El negocio con _synchronisationSent es evitar el encendido del espúreas: ver wikipedia

Answer 3

también sugeriría a marcar tan volátil que waitBo Olean, sin embargo, tienes que usar una condición o incluso mejor una barrera.