std::timed_mutex:: lock

Sperrt den Mutex. Falls ein anderer Thread den Mutex bereits gesperrt hat, blockiert ein Aufruf von lock die Ausführung, bis die Sperre erworben wurde.

Wenn lock von einem Thread aufgerufen wird, der bereits den mutex besitzt, ist das Verhalten undefiniert: Beispielsweise kann das Programm in einen Deadlock geraten. Eine Implementierung, die die ungültige Verwendung erkennen kann, sollte eine std::system_error mit der Fehlerbedingung resource_deadlock_would_occur werfen, anstatt in einen Deadlock zu geraten.

Vorherige unlock() Operationen auf demselben Mutex synchronisieren mit (wie definiert in std::memory_order ) dieser Operation.

Ausnahmen

Wirft std::system_error bei Auftreten von Fehlern, einschließlich Fehlern des zugrundeliegenden Betriebssystems, die verhindern würden, dass lock seine Spezifikationen erfüllen kann. Das Mutex wird im Falle einer ausgelösten Ausnahme nicht gesperrt.

Hinweise

lock() wird normalerweise nicht direkt aufgerufen: std::unique_lock , std::scoped_lock und std::lock_guard werden zur Verwaltung exklusiver Sperren verwendet.

Beispiel

#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

Siehe auch