Definido en el encabezado 
classmutex;
 (desde C ++ 11)

El mutex La clase es una primitiva de sincronización que se puede utilizar para proteger los datos compartidos y evitar que varios subprocesos accedan simultáneamente.

mutex ofrece semántica de propiedad exclusiva y no recursiva:

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

El comportamiento de un programa no está definido si un mutex se destruye mientras aún es propiedad de algún hilo, o un hilo termina mientras posee un mutex. El mutex class satisface todos los requisitos de Mutex y StandardLayoutType.

std::mutex no es copiable ni movible.

Tipos de miembros

Tipo de miembro Definición
native_handle_type(Opcional) definido por la implementación

Funciones de los miembros

(constructor) construye el mutex
(función de miembro público)
(incinerador de basuras) destruye el mutex
(función de miembro público)
operador =[deleted] no copiable
(función de miembro público)
Cierre
cerrar con llave bloquea el mutex, bloquea si el mutex no está disponible
(función de miembro público)
try_lock intenta bloquear el mutex, regresa si el mutex no está disponible
(función de miembro público)
desbloquear desbloquea el mutex
(función de miembro público)
Mango nativo
native_handle devuelve el objeto de identificador nativo definido por la implementación subyacente
(función de miembro público)

Notas

std::mutex generalmente no se accede directamente: std::unique_lock, std::lock_guard, o std::scoped_lock(desde C ++ 17) administrar el bloqueo de una manera más segura para las excepciones.

Ejemplo

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

#include#include#include#include#include#include
 
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;voidsave_page(const std::string &url)// simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result ="fake content";
 
    std::lock_guard<std::mutex>guard(g_pages_mutex);
    g_pages[url]= result;intmain()
    std::thread t1(save_page,"http://foo");
    std::thread t2(save_page,"http://bar");
    t1.join();
    t2.join();// safe to access g_pages without lock now, as the threads are joinedfor(constauto&pair : g_pages)
        std::cout << pair.first <<" => "<< pair.second <<'n';

Producción:

http://bar => fake content
http://foo => fake content