CKTIS / C++
std::lock_guard — possesso del lock legato all’ambito
std::lock_guard di <mutex> gestisce un lock secondo RAII. Il costruttore che riceve solo il mutex lo blocca. La variante con std::adopt_lock assume la responsabilità di un lock esclusivo già detenuto dal thread corrente, senza chiamare lock(). In entrambi i casi, il distruttore sblocca il mutex. Un oggetto con nome protegge una sezione critica per tutta la sua durata.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <mutex>
std::lock_guard<Mutex> guard(m);
std::lock_guard<Mutex> guard(m, std::adopt_lock);std::lock_guard<Mutex> lega il possesso del lock alla durata dell’oggetto (RAII). Il costruttore che riceve m chiama m.lock(), mentre il distruttore chiama m.unlock(). Quando si esce dall’ambito, un lock acquisito correttamente viene rilasciato, anche in caso di return o di unwinding dello stack dopo un’eccezione.
Il tipo Mutex deve soddisfare i requisiti di Cpp17BasicLockable. Il mutex deve esistere per tutta la durata del guard; in caso contrario, il comportamento è indefinito. Il guard non può essere copiato né spostato e non offre un’operazione per sbloccare in anticipo.
La variante con std::adopt_lock assume la responsabilità di un lock già posseduto senza chiamare lock(). Richiede che il thread corrente possieda già un lock esclusivo su quel mutex. Assegna un nome al guard: un oggetto temporaneo viene distrutto alla fine dell’espressione completa e quindi non protegge le istruzioni successive.
Nell’esempio, entrambi i thread proteggono ogni incremento di counter con lo stesso mutex. La lettura avviene solo dopo entrambe le chiamate a join(), quindi il risultato atteso è 2000, indipendentemente dalla pianificazione dei thread.
Esempi
#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';
}
Risultato
2000
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.