Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::lock_guard — propiedad del bloqueo ligada al ámbito

std::lock_guard de <mutex> administra un bloqueo mediante RAII. El constructor que solo recibe el mutex lo bloquea. La sobrecarga con std::adopt_lock asume la responsabilidad de un bloqueo exclusivo que el hilo actual ya posee, sin llamar a lock(). En ambos casos, el destructor desbloquea el mutex. Un objeto con nombre protege una sección crítica durante toda su vida útil.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <mutex>
std::lock_guard<Mutex> guard(m);
std::lock_guard<Mutex> guard(m, std::adopt_lock);

std::lock_guard<Mutex> vincula la propiedad del bloqueo a la vida útil del objeto (RAII). El constructor que recibe m llama a m.lock(), y el destructor llama a m.unlock(). Al salir del ámbito se libera un bloqueo adquirido correctamente, también si se sale mediante return o durante el desenrollado de la pila tras una excepción.

El tipo Mutex debe cumplir los requisitos de Cpp17BasicLockable. El mutex debe existir durante toda la vida útil del guardián; incumplir esta condición provoca comportamiento indefinido. El guardián no se puede copiar ni mover y no ofrece ninguna operación para desbloquear antes de tiempo.

La variante con std::adopt_lock asume la responsabilidad de un bloqueo que ya se posee, sin llamar a lock(). Requiere que el hilo actual ya tenga un bloqueo exclusivo de ese mutex. Ponle un nombre al guardián: un objeto temporal se destruye al final de la expresión completa y, por tanto, no protege las instrucciones siguientes.

En el ejemplo, ambos hilos protegen cada incremento de counter con el mismo mutex. La lectura solo se realiza después de las dos llamadas a join(), así que el resultado esperado es 2000, independientemente de la planificación de los hilos.

Ejemplos

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

int main() {
    std::mutex m;
    int counter = 0;

    auto increment = [&] {
        for (int i = 0; i < 1000; ++i) {
            std::lock_guard<std::mutex> guard(m);
            ++counter;
        }
    };

    std::thread first(increment);
    std::thread second(increment);
    first.join();
    second.join();

    std::cout << counter << '\n';
}

Resultado

2000

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.

Fuentes