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.