Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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.

Fonti