CKTIS / C++
std::scoped_lock — propiedad de bloqueos vinculada al ámbito
std::scoped_lock posee los bloqueos de los mutex durante la vida del objeto. Su constructor bloquea los mutex indicados y su destructor los desbloquea. Para varios mutex, usa std::lock para evitar interbloqueos al adquirirlos conjuntamente.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <mutex>
{
std::scoped_lock guard(m1, m2);
}
{
std::lock(m1, m2);
std::scoped_lock adopted(std::adopt_lock, m1, m2);
}std::scoped_lock, de <mutex>, es un guardián RAII: vincula la posesión de los bloqueos a la vida de un objeto con nombre. Su destructor llama a unlock() para cada mutex, incluso cuando una excepción hace salir del ámbito. El guardián no se puede copiar ni mover; los mutex deben permanecer vivos durante toda su vida.
El constructor ordinario no bloquea nada si no hay mutexes, llama a lock() si hay uno y usa std::lock si hay varios. Un tipo de mutex debe cumplir Cpp17BasicLockable; con varios tipos de mutex, estos deben cumplir Cpp17Lockable. El algoritmo evita interbloqueos al adquirir conjuntamente esos bloqueos, pero no evita todos los interbloqueos de un programa. Si la adquisición mediante std::lock lanza una excepción, esa llamada libera los bloqueos que había adquirido antes de propagarla.
La sobrecarga con std::adopt_lock no bloquea los mutex: asume la responsabilidad de desbloquearlos. El hilo que la llama ya debe tener un bloqueo exclusivo sobre cada uno. No uses el constructor ordinario para volver a bloquear un std::mutex que ya posees. Ponle un nombre al guardián: el objeto temporal de std::scoped_lock{m1, m2}; se destruye al final de esa instrucción.
El ejemplo actualiza dos valores mientras mantiene ambos bloqueos y muestra 7 23 después de liberarlos. Usa deliberadamente un solo hilo para que la salida sea determinista; no demuestra contención entre hilos. En un programa concurrente, todos los accesos a los mismos datos protegidos deben seguir un protocolo de sincronización coherente.
Ejemplos
#include <iostream>
#include <mutex>
int main() {
std::mutex left_mutex;
std::mutex right_mutex;
int left = 10;
int right = 20;
{
std::scoped_lock guard(left_mutex, right_mutex);
left -= 3;
right += 3;
}
std::cout << left << ' ' << right << '\n';
}
Resultado
7 23
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.