std::mutex

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.

[editar] Tipos miembro

[editar] Funciones miembro

[editar] 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.

[editar] Ejemplo

#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';
    }
}

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