2011-08-15 21 views
10

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.¿Cómo hago una sección crítica con Boost?

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(); 
     } 
    } 
} 

Respuesta

11

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.

+1

Su recomendación es muy útil. He solucionado mi error, PERO tengo supresión de rendimiento. ¡más de 3 veces! = ((Antes de que la solución que solía unique_lock ) – Vie

+1

¿Puede proporcionar ejemplos de código en el que utilizando recursos compartidos? También puedes ver este http://home.roadrunner.com/~hinnant/mutexes/locking.html#Shared. Tal vez Será útil. –

+1

Trate de evitar el uso de bloqueo recursivo, puede ser moviendo la protección al alcance externo. Los mutexes recursivos pueden ser más lentos que los simples. – blaze

3

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.

Cuestiones relacionadas