std::timed_mutex:: lock

Bloquea el mutex. Si otro hilo ya ha bloqueado el mutex, una llamada a lock bloqueará la ejecución hasta que se adquiera el bloqueo.

Si lock es llamado por un hilo que ya posee el mutex , el comportamiento es indefinido: por ejemplo, el programa puede bloquearse. Se recomienda que una implementación que pueda detectar el uso inválido lance un std::system_error con condición de error resource_deadlock_would_occur en lugar de bloquearse.

Las operaciones previas de unlock() en el mismo mutex sincronizan-con (como se define en std::memory_order ) esta operación.

Excepciones

Lanza std::system_error cuando ocurren errores, incluyendo errores del sistema operativo subyacente que impedirían que lock cumpla con sus especificaciones. El mutex no queda bloqueado en caso de que se lance cualquier excepción.

Notas

lock() normalmente no se llama directamente: std::unique_lock , std::scoped_lock , y std::lock_guard se utilizan para gestionar el bloqueo exclusivo.

Ejemplo

#include <chrono>
#include <iostream>
#include <mutex>
#include <thread>
int g_num = 0; // protected by g_num_mutex
std::mutex g_num_mutex;
void slow_increment(int id) 
{
    for (int i = 0; i < 3; ++i)
    {
        g_num_mutex.lock(); 
        ++g_num;
        // note, that the mutex also syncronizes the output
        std::cout << "id: " << id << ", g_num: " << g_num << '\n';
        g_num_mutex.unlock();
        std::this_thread::sleep_for(std::chrono::milliseconds(234));
    }
}
int main()
{
    std::thread t1{slow_increment, 0};
    std::thread t2{slow_increment, 1};
    t1.join();
    t2.join();
}

id: 0, g_num: 1
id: 1, g_num: 2
id: 1, g_num: 3
id: 0, g_num: 4
id: 0, g_num: 5
id: 1, g_num: 6

Véase también