std::mutex

 

C++

Lenguaje

Archivos de encabezado de la biblioteca estándar

Implementaciones independientes y albergadas

Requerimientos denominados

Biblioteca de soporte del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de utilerías

Biblioteca de cadenas

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca numérica

Biblioteca de entrada/salida

Biblioteca de localizaciones

Biblioteca de expresiones regulares (C++11)

Biblioteca de operaciones atómicas (C++11)

Biblioteca de soporte de hilos (C++11)

Biblioteca del sistema de archivos (C++17)

Especificaciones técnicas

 

Biblioteca de apoyo de hilos

Hilos/subprocesos
thread (C++11)
jthread (C++20)
stop_token (C++20)
stop_source (C++20)
stop_callback (C++20)
hardware_destructive_interference_sizehardware_constructive_interference_size (C++17)(C++17)
this_thread namespace
get_id (C++11) yield (C++11)	sleep_for (C++11) sleep_until (C++11)
Exclusión mutua
mutex (C++11) recursive_mutex (C++11) shared_mutex (C++17)	timed_mutex (C++11) recursive_timed_mutex (C++11) shared_timed_mutex (C++14)
Gestión de cerrojos genérica
lock_guard (C++11) scoped_lock (C++17) unique_lock (C++11) shared_lock (C++14) defer_lock_ttry_to_lock_tadopt_lock_t (C++11)(C++11)(C++11)	lock (C++11) try_lock (C++11) defer_locktry_to_lockadopt_lock (C++11)(C++11)(C++11) once_flag (C++11) call_once (C++11)
Variables de condición
condition_variable (C++11)
condition_variable_any (C++11)
notify_all_at_thread_exit (C++11)
cv_status (C++11)
Semáforos
counting_semaphorebinary_semaphore (C++20)(C++20)
Pestillos y barreras
latch (C++20)
barrier (C++20)
Futuros
promise (C++11) future (C++11) shared_future (C++11) packaged_task (C++11) async (C++11)	launch (C++11) future_status (C++11) future_error (C++11) future_category (C++11) future_errc (C++11)

 

std::mutex

Funciones miembro

mutex::mutex

mutex::~mutex

Bloqueo

mutex::lock

mutex::try_lock

mutex::unlock

Identificador nativo

mutex::native_handle

 

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

La clase mutex es una primitiva de sincronización que puede usarse para proteger datos compartidos de un acceso simultáneo por varios hilos.

mutex ofrece una semántica de propiedad exclusiva, no recursiva:

• Un hilo llamante posee un mutex a partir del momento en el que llama con éxito a lock o try_lock hasta que llama a unlock.
• Cuando un hilo posee un mutex, los demás hilos se bloquearán (para las llamadas a lock) o recibirán un valor de retorno false (para try_lock) si intentan reclamar la posesión del mutex.
• Un hilo llamante no debe poseer el mutex antes de llamar a lock o try_lock.

El comportamiento de un programa no está definido si un mutex se destruye si todavía se posee por algún hilo, o un hilo termina mientras posee un mutex. La clase mutex satisface todos los requerimientos de Mutex y StandardLayoutType.

std::mutex no es ni copiable ni movible.

Tipos miembro

Tipo Miembro	Definición
native_handle_type(no siempre está presente)	definido por la implementación

Funciones miembro

(constructor)	Construye el mutex (función miembro pública)
(destructor)	Destruye el mutex (función miembro pública)
operator= [eliminada]	No es asignable mediante copia (función miembro pública)
Bloqueo
lock	Bloquea el mutex; se bloquea si el mutex no está disponible (función miembro pública)
try_lock	Intenta bloquear el mutex; regresa si el mutex no está disponible (función miembro pública)
unlock	Desbloquea el mutex (función miembro pública)
Identificador nativo
native_handle	Devuelve el identificador nativo subyacente definido por la implementación (función miembro pública)

Notas

Generalmente no se accede a un std::mutex directamente: std::unique_lock, std::lock_guard, o std::scoped_lock (desde C++17) gestionan el bloqueo de una manera más segura contra excepciones.

Ejemplo

Este ejemplo muestra cómo un mutex puede usarse para proteger un std::map compartido entre dos hilos.

Ejecuta este código

#include <iostream>
#include <map>
#include <string>
#include <chrono>
#include <thread>
#include <mutex>
 
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
 
void save_page(const std::string &url)
{
    // simular la recuperación de una página extensa
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "contenido falso";
 
    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}
 
int main() 
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");
    t1.join();
    t2.join();
 
    // ahora es seguro acceder a g_pages sin bloqueo, ya que los hilos están unidos
    for (const auto &pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << '\n';
    }
}

Salida:

http://bar => contenido falso
http://foo => contenido falso