Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::unique_lock — gestione flessibile dei lock dei mutex

std::unique_lock è un oggetto RAII spostabile ma non copiabile di <mutex> che gestisce la proprietà del lock di un mutex. Consente di rimandare il blocco, sbloccare prima di uscire dall’ambito e bloccare di nuovo. Il distruttore sblocca il mutex solo se l’oggetto possiede ancora il lock.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <mutex>
std::unique_lock<Mutex> lock(mutex);
std::unique_lock<Mutex> lock(mutex, std::defer_lock);

std::unique_lock<Mutex> di <mutex> gestisce la proprietà del lock, non la durata del mutex. Usa RAII: se l’oggetto possiede il lock, il suo distruttore chiama unlock() sul mutex, anche quando un’eccezione provoca l’uscita dall’ambito. Il mutex deve restare valido finché l’oggetto è associato a esso. L’oggetto può essere spostato, ma non copiato.

La costruzione con il solo mutex ne chiama lock(). Il tag std::defer_lock stabilisce un’associazione senza bloccare; std::try_to_lock esegue un tentativo non bloccante, il cui risultato si può verificare con owns_lock() o convertendo a bool. std::adopt_lock richiede che il thread corrente possieda già un lock esclusivo sul mutex; non è un modo per acquisirlo.

lock() e unlock() consentono di cambiare stato prima di uscire dall’ambito. Non chiamare lock() se l’oggetto possiede già il lock, né unlock() se non lo possiede. Mutex deve soddisfare i requisiti di BasicLockable; le operazioni di tentativo di lock richiedono anche Lockable, mentre try_lock_for() e try_lock_until() richiedono TimedLockable. Usare std::unique_lock non aggiunge di per sé il supporto ai timeout a un mutex.

Non confondere release() con unlock(): release() restituisce il puntatore al mutex e rimuove l’associazione, ma non sblocca il mutex. La responsabilità di un eventuale sblocco necessario passa al codice chiamante. L’esempio mostra il blocco differito, lo sblocco esplicito e un nuovo blocco, dopodiché il distruttore rilascia il lock. Un solo thread rende deterministico l’output; l’esempio non mostra la contesa tra thread.

Esempi

#include <iostream>
#include <mutex>

int main() {
    std::mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::mutex> lock(mutex, std::defer_lock);
        std::cout << std::boolalpha << lock.owns_lock() << '\n';
        lock.lock();
        ++value;
        std::cout << lock.owns_lock() << ' ' << value << '\n';
        lock.unlock();
        std::cout << lock.owns_lock() << '\n';
        lock.lock();
    }
    std::cout << value << '\n';
}

Risultato

false
true 1
false
1

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