CKTIS / C++
std::lock_guard — bereichsgebundener Besitz einer Sperre
std::lock_guard aus <mutex> verwaltet eine Sperre nach dem RAII-Prinzip. Der Konstruktor, der nur den Mutex entgegennimmt, sperrt ihn. Die Überladung mit std::adopt_lock übernimmt die Verantwortung für eine exklusive Sperre, die der aktuelle Thread bereits hält, ohne lock() aufzurufen. In beiden Fällen entsperrt der Destruktor den Mutex. Ein benanntes Objekt schützt während seiner gesamten Lebensdauer einen kritischen Abschnitt.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
#include <mutex>
std::lock_guard<Mutex> guard(m);
std::lock_guard<Mutex> guard(m, std::adopt_lock);std::lock_guard<Mutex> bindet den Besitz einer Sperre an die Lebensdauer des Objekts (RAII). Der Konstruktor mit m als Argument ruft m.lock() auf, der Destruktor m.unlock(). Beim Verlassen des Gültigkeitsbereichs wird eine erfolgreich erworbene Sperre freigegeben, auch bei return oder beim Stack-Unwinding nach einer Ausnahme.
Der Typ Mutex muss die Anforderungen von Cpp17BasicLockable erfüllen. Der Mutex muss während der gesamten Lebensdauer des Guards existieren; andernfalls ist das Verhalten undefiniert. Der Guard kann weder kopiert noch verschoben werden und bietet keine Möglichkeit zum vorzeitigen Entsperren.
Die Variante mit std::adopt_lock übernimmt die Verantwortung für eine bereits gehaltene Sperre, ohne lock() aufzurufen. Voraussetzung ist, dass der aktuelle Thread bereits eine exklusive Sperre für diesen Mutex hält. Gib dem Guard einen Namen: Ein temporäres Objekt wird am Ende des vollständigen Ausdrucks zerstört und schützt daher nicht die folgenden Anweisungen.
Im Beispiel schützen beide Threads jedes Erhöhen von counter mit demselben Mutex. Gelesen wird erst nach beiden Aufrufen von join(), daher ist das erwartete Ergebnis unabhängig von der Thread-Scheduling-Reihenfolge 2000.
Beispiele
#include <iostream>
#include <mutex>
#include <thread>
int main() {
std::mutex m;
int counter = 0;
auto increment = [&] {
for (int i = 0; i < 1000; ++i) {
std::lock_guard<std::mutex> guard(m);
++counter;
}
};
std::thread first(increment);
std::thread second(increment);
first.join();
second.join();
std::cout << counter << '\n';
}
Ergebnis
2000
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.