std::shared_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 den mutex bereits in einem beliebigen Modus (shared oder exclusive) besitzt, ist das Verhalten undefiniert.

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.

Shared Mutexe unterstützen keinen direkten Übergang vom gemeinsamen in den exklusiven Besitzmodus: Die gemeinsame Sperre muss mit unlock_shared() aufgegeben werden, bevor exklusiver Besitz mit lock() erlangt werden kann. boost::upgrade_mutex kann für diesen Zweck verwendet werden.

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