std::shared_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 en cualquier modo (compartido o exclusivo), el comportamiento es indefinido.

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.

Los mutex compartidos no admiten la transición directa del modo de propiedad compartida al modo de propiedad exclusiva: el bloqueo compartido debe ser liberado con unlock_shared() antes de que pueda obtenerse la propiedad exclusiva con lock() . boost::upgrade_mutex puede utilizarse para este propósito.

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