Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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.

Fonti