std:: mutex

La clase mutex es un primitivo de sincronización que puede utilizarse para proteger datos compartidos de ser accedidos simultáneamente por múltiples hilos.

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

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

El comportamiento de un programa es indefinido si un mutex es destruido mientras aún está siendo poseído por algún hilo, o si un hilo termina mientras posee un mutex . La clase mutex satisface todos los requisitos de Mutex y StandardLayoutType .

std::mutex no es copiable ni movible.

Tipos anidados

Funciones miembro

Notas

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

Ejemplo

#include <chrono>
#include <iostream>
#include <map>
#include <mutex>
#include <string>
#include <thread>
std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;
void save_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;
}
int main() 
{
    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 joined
    for (const auto& [url, page] : g_pages)
        std::cout << url << " => " << page << '\n';
}

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

Véase también