Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::shared_mutex — blocco condiviso ed esclusivo

std::shared_mutex consente a più thread di detenere contemporaneamente il blocco condiviso, oppure a un solo thread di detenere quello esclusivo. Usa std::shared_lock per leggere e std::unique_lock per scrivere, seguendo lo stesso protocollo per ogni accesso ai dati protetti.

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

Sintassi

#include <shared_mutex>
#include <mutex>

std::shared_mutex m;
// In separate scopes:
{ std::shared_lock<std::shared_mutex> read_lock(m); }
{ std::unique_lock<std::shared_mutex> write_lock(m); }

std::shared_mutex, dichiarato in <shared_mutex>, è un mutex non ricorsivo. La modalità condivisa consente più possessori contemporaneamente; quella esclusiva esclude tutti gli altri possessori. Il protocollo abituale prevede letture con possesso condiviso e modifiche con possesso esclusivo. Il mutex non controlla da solo l'accesso alle variabili: il codice deve seguire il protocollo in modo coerente.

lock() e unlock() gestiscono il possesso esclusivo, mentre lock_shared() e unlock_shared() gestiscono quello condiviso. Le operazioni bloccanti attendono che sia possibile acquisire il possesso. try_lock() e try_lock_shared() tentano di acquisirlo senza attendere e restituiscono bool; possono fallire in modo spurio, quindi false non dimostra che il mutex sia posseduto da un altro thread.

Preferisci RAII allo sblocco manuale: usa std::shared_lock<std::shared_mutex> di <shared_mutex> per i lettori e std::unique_lock<std::shared_mutex> di <mutex> per gli scrittori. Questi oggetti rilasciano il blocco posseduto quando il loro ambito termina, anche durante la propagazione di un'eccezione. Il possesso condiviso non fornisce l'esclusività necessaria per le normali modifiche ai dati condivisi.

Non tentare di acquisire di nuovo nessuno dei due tipi di possesso in un thread che possiede già lo stesso mutex: il comportamento è indefinito. Questo include il tentativo di acquisire il possesso esclusivo senza rilasciare quello condiviso. Sbloccare e bloccare di nuovo non è un cambio di modalità atomico: nel frattempo i dati possono cambiare. Non distruggere un mutex posseduto né lasciare che un thread termini mentre lo possiede ancora.

L'esempio separa la scrittura dalla lettura mediante join() e protegge ogni accesso a value con il blocco appropriato. I lettori possono essere eseguiti contemporaneamente, ma non è necessario; memorizzano i risultati in variabili separate. La stampa dopo entrambe le chiamate a join() produce il risultato deterministico 42 42.

Esempi

#include <iostream>
#include <mutex>
#include <shared_mutex>
#include <thread>

int main() {
    std::shared_mutex mutex;
    int value = 0;

    std::thread writer([&] {
        std::unique_lock<std::shared_mutex> lock(mutex);
        value = 42;
    });
    writer.join();

    int first = 0;
    int second = 0;
    std::thread reader1([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        first = value;
    });
    std::thread reader2([&] {
        std::shared_lock<std::shared_mutex> lock(mutex);
        second = value;
    });
    reader1.join();
    reader2.join();

    std::cout << first << ' ' << second << '\n';
}

Risultato

42 42

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