CKTIS / C++
std::lock_guard — lockbezit gebonden aan de scope
std::lock_guard uit <mutex> beheert een lock met RAII. De constructor die alleen de mutex als argument krijgt, vergrendelt die mutex. De variant met std::adopt_lock neemt de verantwoordelijkheid over voor een exclusieve lock die de huidige thread al bezit, zonder lock() aan te roepen. In beide gevallen ontgrendelt de destructor de mutex. Een benoemd object beschermt gedurende zijn hele levensduur een kritieke sectie.
Versie: 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> koppelt het bezit van de lock aan de levensduur van het object (RAII). De constructor met m als argument roept m.lock() aan; de destructor roept m.unlock() aan. Bij het verlaten van de scope wordt een succesvol verkregen lock vrijgegeven, ook bij return of stack unwinding na een uitzondering.
Het type Mutex moet voldoen aan de eisen van Cpp17BasicLockable. De mutex moet gedurende de hele levensduur van de guard bestaan; als dat niet zo is, is het gedrag ongedefinieerd. De guard kan niet worden gekopieerd of verplaatst en biedt geen mogelijkheid om voortijdig te ontgrendelen.
De variant met std::adopt_lock neemt de verantwoordelijkheid voor een al in bezit zijnde lock over zonder lock() aan te roepen. De huidige thread moet daarvoor al een exclusieve lock op die mutex bezitten. Geef de guard een naam: een tijdelijk object wordt aan het einde van de volledige expressie vernietigd en beschermt dus niet de daaropvolgende instructies.
In het voorbeeld beschermen beide threads elke verhoging van counter met dezelfde mutex. De waarde wordt pas gelezen na beide aanroepen van join(), dus het verwachte resultaat is 2000, ongeacht de threadplanning.
Voorbeelden
#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';
}
Resultaat
2000
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.