Espacios de nombres
Variantes
Acciones

std::lock_guard

De cppreference.com
< cpp‎ | thread
 
 
Biblioteca de apoyo de concurrencia
Hilos
(C++11)
(C++20)
Espacio de nombres this_thread
(C++11)
(C++11)
(C++11)
Cancelación cooperativa
Exclusión mutua
(C++11)
Gestión genérica de bloqueo
(C++11)
lock_guard
(C++11)
(C++11)
(C++11)
(C++11)
Variables de condición
(C++11)
Semáforos
Pestillos y barreras
(C++20)
(C++20)
Futuros
(C++11)
(C++11)
(C++11)
(C++11)
Recuperación segura
(C++26)
Punteros de riesgo
Tipos atómicos
(C++11)
(C++20)
Inicialización de tipos atómicos
(C++11)(en desuso en C++20)
(C++11)(en desuso en C++20)
Orden de memoria
Funciones independientes para operaciones atómicas
Funciones independientes para indicadores atómicos
 
std::lock_guard
 
Definido en el archivo de encabezado <mutex>
template< class Mutex >
class lock_guard;
(desde C++11)

La clase lock_guard o guarda de cerrojo, es un envoltorio de mutex que proporciona un mecanismo estilo RAII conveniente para poseer un mutex durante la duración del ámbito de un bloque.

Cuando se crea un objeto lock_guard, intenta tomar posesión del mutex que se le da. Cuando el control abandona el ámbito en el que se creó el objeto lock_guard, el objeto lock_guard se destruye y el mutex se libera.

La clase lock_guard no se puede copiar.

std::scoped_lock ofrece un reemplazo para lock_guard que proporciona la capacidad de bloquear múltiples mutex mediante un algoritmo de evitación de interbloqueo.

(desde C++17)

Contenido

[editar] Parámetros de plantilla

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

[editar] Tipos miembro

Tipo miembro Definición
mutex_type Mutex

[editar] Funciones miembro

Construye un objeto lock_guard, opcionalmente bloquea el mutex dado.
(función miembro pública) [editar]
Destruye el objeto lock_guard, desbloquea el mutex subyacente.
(función miembro pública) [editar]
operator=
[eliminada]
No es asignable mediante copia.
(función miembro pública) [editar]

[editar] Ejemplo

#include <thread>
#include <mutex>
#include <iostream>
 
int g_i = 0;
std::mutex g_i_mutex;  // protege a g_i
 
void incremento_seguro()
{
    const std::lock_guard<std::mutex> lock(g_i_mutex);
    ++g_i;
 
    std::cout << "g_i: " << g_i << "; en el hilo #"
              << std::this_thread::get_id() << '\n';
 
    // g_i_mutex se libera automáticamente cuando el cerrojo
    // sale de ámbito
}
 
int main()
{
    std::cout << "g_i: " << g_i << "; en main()\n";
 
    std::thread t1(incremento_seguro);
    std::thread t2(incremento_seguro);
 
    t1.join();
    t2.join();
 
    std::cout << "g_i: " << g_i << "; en main()\n";
}

Posible salida:

g_i: 0; en main()
g_i: 1; en el hilo #140487981209344
g_i: 2; en el hilo #140487972816640
g_i: 2; en main()

[editar] 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ó guía de deducción redundante de lock_guard<Mutex>. Se eliminó.

[editar] Véase también

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