c++ - boost scoped_lock vs bloqueo/desbloqueo simple

thread-safety mutex

Question

Voy a usar boost::mutex de boost/thread/mutex.hpp . Hay varias formas de bloquear / desbloquear mutex: con scoped_lock , unique_lock , lock_guard , mutex''s member functions ::lock() y ::unlock() y las funciones nonmember lock() y unlock() .

Me di cuenta de que boost::scoped_mutex es una de las formas más populares de usar mutex. ¿Por qué es preferible para miembros funciones ::lock() y ::unlock() ?

Particularmente, ¿por qué debería usar

{
  boost::scoped_lock lock(mutex)
  // ...
  // read/output sharing memory.
  // ...
}

más bien que

mutex.lock()
// ...
// read/output sharing memory.
// ...
mutex.unlock()

¿ scoped_lock es mejor solo por algún punto de vista de codificación de estilo o is ::lock()/::unlock() no es "thread safe enough"?

Answer 1

¿Por qué es preferible para miembros funciones :: lock () y :: unlock ()?

Por la misma razón, el lenguaje RAII se hizo popular en general (este es solo uno de sus innumerables ejemplos): porque puede estar seguro de que no abandona el alcance actual sin desbloquear el mutex.

Tenga en cuenta que esto no se trata solo de olvidar llamar a unlock() : una excepción puede ocurrir mientras su mutex está bloqueado, y su llamada para unlock() nunca puede ser alcanzada, incluso si no tiene ninguna declaración de return entre su llamada a lock() y su llamada para unlock() .

m.lock() // m is a mutex
// ...
foo(); // If this throws, your mutex won''t get unlocked
// ...
m.unlock()

En este caso, se invocará el destructor de su guardia con scoped_lock durante el desenrollado de la pila, asegurándose de que la scoped_lock asociada siempre se libere.

{
    boost::scoped_lock lock(m); // m is a mutex
    // ...
    foo(); // If this throws, your RAII wrapper will unlock the mutex
    // ...
}

Además, en muchas situaciones esto mejorará la legibilidad de su código, ya que no tendrá que agregar una llamada para unlock() antes de cada declaración de return .

Answer 2

puedes usar

std::lock_guard<std::mutex> lock(mutex);

si no quieres usar la biblioteca de impulso.