CKTIS / C++
std::scoped_lock — possesso dei lock legato all'ambito
std::scoped_lock possiede i lock dei mutex per tutta la durata dell'oggetto. Il costruttore blocca i mutex indicati e il distruttore li sblocca. Con più mutex, usa std::lock per evitare deadlock durante la loro acquisizione congiunta.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <mutex>
{
std::scoped_lock guard(m1, m2);
}
{
std::lock(m1, m2);
std::scoped_lock adopted(std::adopt_lock, m1, m2);
}std::scoped_lock, definito in <mutex>, è una guardia RAII: lega il possesso dei lock alla durata di un oggetto con nome. Il suo distruttore chiama unlock() su ciascun mutex, anche quando un'eccezione provoca l'uscita dall'ambito. La guardia non può essere copiata né spostata; i mutex devono rimanere in vita per tutta la sua durata.
Il costruttore ordinario non blocca nulla con zero mutex, chiama lock() con un mutex e usa std::lock con più mutex. Un tipo di mutex deve soddisfare Cpp17BasicLockable; con più tipi di mutex, questi devono soddisfare Cpp17Lockable. L'algoritmo evita i deadlock quando acquisisce insieme questi lock, ma non impedisce tutti i deadlock in un programma. Se l'acquisizione tramite std::lock genera un'eccezione, la chiamata rilascia i lock acquisiti prima di propagare l'eccezione.
L'overload con std::adopt_lock non blocca i mutex: assume la responsabilità di sbloccarli. Il thread chiamante deve già detenere un lock esclusivo su ciascuno. Non usare il costruttore ordinario per bloccare di nuovo un std::mutex già posseduto. Assegna un nome alla guardia: l'oggetto temporaneo in std::scoped_lock{m1, m2}; viene distrutto alla fine di quell'istruzione.
L'esempio aggiorna due valori mentre detiene entrambi i lock e stampa 7 23 dopo averli rilasciati. Usa intenzionalmente un solo thread per rendere deterministico l'output; non dimostra la contesa tra thread. In un programma concorrente, tutti gli accessi agli stessi dati protetti devono seguire un protocollo di sincronizzazione coerente.
Esempi
#include <iostream>
#include <mutex>
int main() {
std::mutex left_mutex;
std::mutex right_mutex;
int left = 10;
int right = 20;
{
std::scoped_lock guard(left_mutex, right_mutex);
left -= 3;
right += 3;
}
std::cout << left << ' ' << right << '\n';
}
Risultato
7 23
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.