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

Ein Thread kann lock auf einen rekursiven Mutex wiederholt aufrufen. Der Besitz wird erst freigegeben, nachdem der Thread eine entsprechende Anzahl von Aufrufen von unlock durchgeführt hat.

Die maximale Anzahl an Ebenen von Eigentümerschaft ist nicht spezifiziert. Eine Ausnahme vom Typ std::system_error wird geworfen, wenn diese Anzahl überschritten wird.

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