¿Cuál es la diferencia entre "mutex" y "lock"?

Question

Estoy muy confundido acerca de la diferencia entre un bloqueo y mutex. En documentos Boost, que dice,

Tipos

Lock

• plantilla de clase lock_guard
• plantilla de clase unique_lock
• plantilla de clase shared_lock
• plantilla de clase upgrade_lock
• plantilla de clase upgrade_to_unique_lock
• Clase específica de Mutex scoped_tr y_lock

Tipos Mutex

• mutex Clase
• typedef try_mutex
• timed_mutex Clase
• recursive_mutex Clase
• typedef recursive_try_mutex
• recursive_timed_mutex Clase
• shared_mutex Clase

En otro artículo, veo funciones como este,

boost::shared_mutex _access; 
void reader() 
{ 
    boost::shared_lock<boost::shared_mutex> lock(_access); 
    // do work here, without anyone having exclusive access 
}  
void conditional_writer() 
{ 
    boost::upgrade_lock<boost::shared_mutex> lock(_access); 
    // do work here, without anyone having exclusive access 

    if (something) { 
    boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock); 
    // do work here, but now you have exclusive access 
    } 
    // do more work here, without anyone having exclusive access 
} 

preguntas Actualizado

1. ¿Alguien puede ofrecer algunas aclaraciones entre el "mutex" y " bloquear"?
2. ¿Es necesario crear un shared_lock para un shared_mutex? ¿Qué ocurre si creo un unique_lock para un shared_mutex?
3. O si creo un shared_lock de un mutex, significa la exclusión mutua puede no puede compartir entre varios hilos?

Answer 1

A mutex es un objeto de sincronización. Adquiere un bloqueo en un mutex al principio de una sección de código y lo suelta al final, para garantizar que ningún otro hilo acceda a los mismos datos al mismo tiempo. Un mutex generalmente tiene una vida igual a la de los datos que protege, y se accede a un mutex por múltiples hilos.

A objeto de bloqueo es un objeto que encapsula ese bloqueo.Cuando se construye el objeto, adquiere el bloqueo en el mutex. Cuando se destruye, se libera la cerradura. Por lo general, crea un nuevo objeto de bloqueo para cada acceso a los datos compartidos.

Answer 2

Un mutex es un objeto que se puede bloquear. Un bloqueo es el objeto que mantiene el bloqueo. Para crear un candado, debes pasarle un mutex.

Answer 3

cerraduras pueden proporcionar la exclusión mutua, pero no condicionar synchronization.Unlike un semáforo, una cerradura tiene un propietario, y la propiedad juega un importante papel en el comportamiento de una cerradura

ejemplo -

class lockableObject { public void F() { 
mutex.lock(); ...; mutex.unlock(); 
} 
public void G() { 
mutex.lock(); ...; F(); ...; mutex.unlock(); 
} 
private mutexLock mutex; } 
// method G() calls method F() 

Bloquear mutex en la clase lockableObject se usa para convertir los métodos F() y G() en secciones críticas. Por lo tanto, solo se puede ejecutar un subproceso a la vez dentro de un método de un objeto bloqueable. Cuando un hilo llama al método G(), el mutex está bloqueado. Cuando el método G() llama al método F(), mutex.lock() se ejecuta en F(), pero el hilo que llama no está bloqueado, ya que posee mutex. Si mutex fuera un semáforo binario en lugar de un bloqueo, la llamada de G() a F() bloquearía el hilo de llamada cuando se ejecutara mutex.P() en F(). (Recuerde que las finalizaciones de las operaciones P() y V() en un semáforo binario deben alternar). Esto crearía un interbloqueo ya que no se podrían ejecutar otros subprocesos dentro de F() o G().

Estas son las diferencias entre los bloqueos y semáforos binarios: 1 Para un semáforo binario, si se hacen dos llamadas a P() sin ninguna llamada intermedia a V(), la segunda llamada se bloqueará. Pero un hilo que posee un bloqueo y solicita la propiedad nuevamente no está bloqueado. (Tenga cuidado con el hecho de que los bloqueos no siempre son recursivos, por lo tanto, consulte la documentación antes de usar un candado). 2 El propietario de las llamadas sucesivas para bloquear() y desbloquear() debe ser del mismo hilo. Pero las llamadas sucesivas a P() y V() pueden realizarse por diferentes hilos.