std::recursive_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.

Un hilo puede llamar lock en un mutex recursivo repetidamente. La propiedad solo se liberará después de que el hilo realice un número equivalente de llamadas a unlock .

El número máximo de niveles de propiedad no está especificado. Se lanzará una excepción de tipo std::system_error si se excede este número.

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