CKTIS / C++
std::mutex — mutua esclusione tra thread
std::mutex, definito in <mutex>, consente a un solo thread alla volta di possedere il lock. Protegge i dati condivisi quando tutti gli accessi in conflitto seguono lo stesso protocollo di lock. std::lock_guard gestisce il rilascio del lock all’interno di uno scope.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <mutex>
std::mutex m;
std::lock_guard<std::mutex> guard(m);std::mutex, definito in <mutex>, fornisce il possesso esclusivo e non ricorsivo di un lock. Una sezione critica è il codice eseguito mentre si possiede il lock. Un mutex non protegge automaticamente i dati: tutti gli accessi che possono entrare in conflitto devono seguire lo stesso protocollo di sincronizzazione.
lock() attende di acquisire il lock. try_lock() non attende e segnala se l’operazione è riuscita; può restituire false anche se il mutex è disponibile. unlock() rilascia il lock e può essere chiamato solo da chi lo possiede. Il rilascio si sincronizza con una successiva acquisizione riuscita dello stesso mutex, rendendo visibili le scritture precedenti.
È preferibile usare un oggetto con nome std::lock_guard<std::mutex>: il suo costruttore blocca il mutex e il suo distruttore lo sblocca, anche quando un’eccezione causa l’uscita dallo scope. Il mutex deve restare in vita più a lungo del guard. Non tentare di acquisire di nuovo uno std::mutex che possiedi già: non supporta la ricorsione. Non può essere copiato né spostato, e distruggere un mutex posseduto causa un comportamento indefinito.
Nell’esempio, due thread incrementano counter usando lo stesso lock. Ogni chiamata a join() attende solo la terminazione del thread rappresentato dall’oggetto su cui viene effettuata. Prima di leggere il contatore, l’esempio attende separatamente i due thread con first.join() e second.join(), quindi il risultato è 2000 indipendentemente dall’ordine di esecuzione. L’esempio usa funzionalità disponibili in C++23; lo standard di compilazione indicato non certifica un ambiente di esecuzione di produzione. La fonte citata è una bozza di standard in evoluzione, non un’edizione C++23 immutabile.
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.