◐ Shell
clean mode source ↗

std::recursive_mutex - cppreference.com

De cppreference.com

Definido en el archivo de encabezado <mutex>

class recursive_mutex;

 (desde C++11)

La clase recursive_mutex es una primitiva de sincronización que se puede usar para proteger los datos compartidos para que no se accedan simultáneamente por varios hilos.

recursive_mutex ofrece semántica de propiedad recursiva exclusiva:

  • Un hilo llamante posee un recursive_mutex durante un período de tiempo que comienza cuando llama con éxito a lock o try_lock. Durante este período, el hilo puede realizar llamadas adicionales a lock o try_lock. El período de posesión termina cuando el hilo hace un número coincidente de llamadas a unlock.
  • Cuando un hilo posee un recursive_mutex, todos los demás hilos se bloquearán (para llamadas a lock) o recibirán un valor de retorno false (para try_lock) si intentan reclamar la posesión del recursive_mutex.
  • El número máximo de veces que se puede bloquear un recursive_mutex no está especificado, pero una vez que se alcanza ese número, las llamadas a lock lanzarán std::system_error y las llamadas a try_lock devolverán false.

El comportamiento de un programa no está definido si se destruye un recursive_mutex mientras todavía es posesión de algún hilo. La clase recursive_mutex satisface todos los requerimientos de Mutex y StandardLayoutType.

Tipos miembro

Tipo miembro Definición
native_handle_type(no siempre está presente) definido por la implementación[editar]

Funciones miembro

Construye el mutex
(función miembro pública) [editar]
Destruye el mutex
(función miembro pública) [editar]

operator=

[eliminada]

 No es asignable mediante copia
(función miembro pública) [editar]
Bloqueo
Bloquea el mutex; se bloquea si el mutex no está disponible
(función miembro pública) [editar]
Intenta bloquear el mutex; regresa si el mutex no está disponible
(función miembro pública) [editar]
Desbloquea el mutex
(función miembro pública) [editar]
Identificador nativo
Devuelve el identificador nativo subyacente definido por la implementación
(función miembro pública) [editar]

Ejemplo

Un caso de uso para recursive_mutex es proteger el estado compartido en una clase cuyas funciones miembro pueden llamarse entre sí.

#include <iostream>
#include <thread>
#include <mutex>

class X {
    std::recursive_mutex m;
    std::string compartida; // cadena compartida
  public:
    void fun1() {
      std::lock_guard<std::recursive_mutex> lk(m);
      compartida = "fun1";
      std::cout << "en fun1, la variable compartida ahora es " << compartida << '\n';
    }
    void fun2() {
      std::lock_guard<std::recursive_mutex> lk(m);
      compartida = "fun2";
      std::cout << "en fun2, la variable compartida " << compartida << '\n';
      fun1(); // aquí el bloqueo recursivo se hace útil
      std::cout << "de vuelta a fun2, la variable compartida es " << compartida << '\n';
    };
};

int main() 
{
    X x;
    std::thread t1(&X::fun1, &x);
    std::thread t2(&X::fun2, &x);
    t1.join();
    t2.join();
}

Posible salida: 

en fun1, la variable compartida ahora es fun1
en fun2, la variable compartida fun2
en fun1, la variable compartida ahora es fun1
de regreso a fun2, la variable compartida es fun1