std::unique_lock - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<mutex>`
`template< class Mutex > class unique_lock;`		(desde C++11)

La clase unique_lock es un envoltorio de propiedad de mutex de propósito general que permite el bloqueo diferido, intentos de bloqueo por tiempo limitado, bloqueo recursivo, transferencia de propiedad de bloqueo y uso con variables de condición.

La clase unique_lock se puede mover, pero no se puede copiar; cumple con los requerimientos de MoveConstructible y MoveAssignable pero no de CopyConstructible o CopyAssignable.

La clase unique_lock cumple con los requerimientos de BasicLockable. Si Mutex cumple con los requerimientos de Lockable, unique_lock también cumple con los requerimientos de Lockable (p. ej., se puede usar en std::lock); si Mutex cumple con los requerimientos de TimedLockable, unique_lock también cumple con los requerimientos de TimedLockable.

Parámetros de plantilla

Mutex

El tipo de mutex a bloquear. El tipo debe cumplir con los requerimientos de BasicLockable.

Tipos miembro

Tipo	Definición
`mutex_type`	`Mutex`

Funciones miembro

(constructor)	Construye un objeto `unique_lock`, y opcionalmente bloquea el mutex suplementado (es decir, toma posesión). (función miembro pública) [editar]
(destructor)	Desbloquea el mutex asociado, si es que lo posee (es decir, libera su posesión). (función miembro pública) [editar]
operator=	Desbloquea el mutex (es decir, libera la posesión) si es que se posee, y toma posesión de otro. (función miembro pública) [editar]
Bloqueo
lock	Bloquea el mutex asociado (es decir, toma posesión). (función miembro pública) [editar]
try_lock	Intenta bloquear el mutex asociado (es decir, tomar posesión) sin bloquearse. (función miembro pública) [editar]
try_lock_for	Intenta bloquear el mutex TimedLockable asociado; es decir, de tomar posesión. Regresa si el mutex no ha estado disponible por la duración de tiempo especificada. (función miembro pública) [editar]
try_lock_until	Intenta bloquear el mutex TimedLockable asociado; es decir, de tomar posesión. Regresa si el mutex no ha estado disponible hasta que se alcance un punto de tiempo especificado. (función miembro pública) [editar]
unlock	Desbloquea el mutex asociado; es decir, libera su posesión. (función miembro pública) [editar]
Modificadores
swap	Intercambia el estado con otro std::unique_lock. (función miembro pública) [editar]
release	Desasocia el mutex asociado (es decir, libera su posesión) sin bloquearse. (función miembro pública) [editar]
Observadores
mutex	Devuelve un puntero al mutex asociado. (función miembro pública) [editar]
owns_lock	Comprueba si el cerrojo posee (es decir, ha bloqueado) su mutex asociado. (función miembro pública) [editar]
operator bool	Comprueba si el cerrojo posee (es decir, ha bloqueado) su mutex asociado. (función miembro pública) [editar]

Funciones no miembro

Ejemplo

#include <mutex>
#include <thread>
#include <chrono>

struct Caja {
    explicit Caja(int num) : num_cosas{num} {}

    int num_cosas;
    std::mutex m;
};

void transferir(Caja &de, Caja &a, int num)
{
    // no hay que tomar los cerrojos todavía
    std::unique_lock<std::mutex> lock1(de.m, std::defer_lock);
    std::unique_lock<std::mutex> lock2(a.m, std::defer_lock);

    // bloquear ambos unique_locks sin interbloqueo
    std::lock(lock1, lock2);

    de.num_cosas -= num;
    a.num_cosas += num;

    // los mutex 'de.m' y 'a.m' se han desbloqueado en los dtores de 'unique_lock'
}

int main()
{
    Caja acc1(100);
    Caja acc2(50);

    std::thread t1(transferir, std::ref(acc1), std::ref(acc2), 10);
    std::thread t2(transferir, std::ref(acc2), std::ref(acc1), 5);

    t1.join();
    t2.join();
}

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2981	C++17	Se proporcionó una guía de deducción redundante de `unique_lock<Mutex>`.	Se eliminó.

Véase también

	Implementa un envoltorio de propiedad de mutex estrictamente basado en un ámbito. (plantilla de clase) [editar]
	Envoltorio RAII que evita bloqueo mutuo para múltiples mutex. (plantilla de clase) [editar]