Namensräume
Varianten
Aktionen

std::recursive_timed_mutex::lock

Von cppreference.com
 
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
this_thread Namespace
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Bedingungsvariablen
(C++11)
Semaphoren
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
Hazard Pointer
Atomare Typen
(C++11)
(C++20)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
Speicherordnung
(C++11)(deprecated in C++26)
Freie Funktionen für atomare Operationen
Freie Funktionen für atomare Flags
 
 
void lock();
(seit C++11)

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

Ein Thread kann lock für einen rekursiven Mutex wiederholt aufrufen. Der Besitz wird erst freigegeben, nachdem der Thread eine entsprechende Anzahl von unlock-Aufrufen getätigt hat.

Die maximale Anzahl von Besitzebenen ist nicht spezifiziert. Eine Ausnahme vom Typ std::system_error wird ausgelöst, wenn diese Anzahl überschritten wird.

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

Inhalt

[bearbeiten] Parameter

(keine)

[bearbeiten] Rückgabewert

(keine)

[bearbeiten] Ausnahmen

Wirft std::system_error bei Fehlern, einschließlich Fehlern des zugrunde liegenden Betriebssystems, die verhindern, dass lock seine Spezifikationen erfüllt. Die Mutex ist im Falle einer geworfenen Ausnahme nicht gesperrt.

[bearbeiten] Hinweise

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


[bearbeiten] Beispiel

Dieses Beispiel zeigt, wie lock und unlock zum Schutz gemeinsamer Daten verwendet werden können.

#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();
}

Mögliche Ausgabe

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

[bearbeiten] Siehe auch

versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex nicht verfügbar ist
(public member function) [edit]
versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex
für die angegebene Zeitdauer nicht verfügbar war
(public member function) [edit]
versucht, den Mutex zu sperren, kehrt zurück, wenn der Mutex
bis zum Erreichen des angegebenen Zeitpunktpunkts nicht verfügbar
(public member function) [edit]
entsperrt den Mutex
(public member function) [edit]
C-Dokumentation für mtx_lock