¿Cómo hago una sección crítica con Boost?

Question

para mi aplicación multiplataforma que han comenzado a usar Boost, pero no puedo entender cómo puedo implementar el código para reproducir el comportamiento de la sección crítica de Win32 o .Net de lock.

Quiero escribir un método Foo que se puede llamar desde diferentes hilos para controlar las operaciones de escritura a campos compartidos. Se deben permitir llamadas recursivas dentro del mismo subproceso (Foo() -> Foo()).

En C# esta aplicación es muy simple:

object _synch = new object(); 
void Foo() 
{ 
    lock (_synch) // one thread can't be lock by him self, but another threads must wait untill 
    { 
     // do some works 
     if (...) 
     { 
      Foo(); 
     } 
    } 
} 

Answer 1

Con impulso puede utilizar impulso :: lock_guard <> clase:

class test 
{ 
public: 
void testMethod() 
{ 
    // this section is not locked 
    { 
    boost::lock_guard<boost::recursive_mutex> lock(m_guard); 
    // this section is locked 
    } 
    // this section is not locked 
} 
private: 
    boost::recursive_mutex m_guard; 
}; 

PS Estas clases ubicadas en Boost.Thread biblioteca.

Answer 2

Aquí es una reescritura de tu ejemplo, usando Boost.Thread: He quitado los comentarios, pero por lo demás, que debería ser una reescritura 1-a-1.

boost::recursive_mutex mtx; 

void Foo() 
{ 
    boost::lock_guard<boost::recursive_mutex> lock(mtx); 
    if (...) 
    { 
     Foo(); 
    } 
} 

La documentación se puede encontrar here.

Tenga en cuenta que Boost define un número de diferentes tipos de exclusión mutua. Como su ejemplo muestra que el bloqueo se toma recursivamente, necesitamos usar al menos boost::recursive_mutex.

También hay diferentes tipos de cerraduras. En particular, si desea un bloqueo lector-escritor (para que varios lectores puedan mantener el bloqueo simultáneamente, siempre que ningún escritor tenga el bloqueo), puede usar boost::shared_lock en lugar de lock_guard.