CKTIS / C++
std::unique_lock — gestión flexible de bloqueos de mutex
std::unique_lock es un objeto RAII movible, pero no copiable, de <mutex> que gestiona la propiedad del bloqueo de un mutex. Permite aplazar el bloqueo, desbloquear antes de salir del ámbito y volver a bloquear. Su destructor desbloquea el mutex solo si el objeto aún posee el bloqueo.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);std::unique_lock<Mutex> de <mutex> gestiona la propiedad del bloqueo, no la vida útil del mutex. Usa RAII: si el objeto posee el bloqueo, su destructor llama a unlock() en el mutex, incluso cuando una excepción provoca la salida del ámbito. El mutex debe seguir existiendo mientras el objeto esté asociado a él. El objeto se puede mover, pero no copiar.
La construcción con solo un mutex llama a su lock(). La etiqueta std::defer_lock establece una asociación sin bloquear; std::try_to_lock realiza un intento no bloqueante cuyo resultado puedes comprobar con owns_lock() o convirtiéndolo a bool. std::adopt_lock exige que el hilo actual ya tenga un bloqueo exclusivo del mutex; no sirve para adquirirlo.
lock() y unlock() permiten cambiar el estado antes de salir del ámbito. No llames a lock() si el objeto ya posee el bloqueo, ni a unlock() si no lo posee. Mutex debe cumplir los requisitos de BasicLockable; las operaciones de intento de bloqueo requieren además Lockable, mientras que try_lock_for() y try_lock_until() requieren TimedLockable. Usar std::unique_lock no añade por sí mismo compatibilidad con tiempos límite a un mutex.
No confundas release() con unlock(): release() devuelve el puntero al mutex y elimina la asociación, pero no desbloquea el mutex. La responsabilidad de desbloquearlo, si hace falta, pasa al código que realiza la llamada. El ejemplo muestra el bloqueo aplazado, el desbloqueo explícito y un nuevo bloqueo, tras el cual el destructor libera el bloqueo. Al haber un solo hilo, la salida es determinista; el ejemplo no muestra contención entre hilos.
Ejemplos
#include <iostream>
#include <mutex>
int main() {
std::mutex mutex;
int value = 0;
{
std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
std::cout << std::boolalpha << lock.owns_lock() << '\n';
lock.lock();
++value;
std::cout << lock.owns_lock() << ' ' << value << '\n';
lock.unlock();
std::cout << lock.owns_lock() << '\n';
lock.lock();
}
std::cout << value << '\n';
}
Resultado
false true 1 false 1
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.