Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::shared_lock — gestire il possesso condiviso di un lock

std::shared_lock di <shared_mutex> gestisce il possesso condiviso di un lock tramite RAII. Consente a più thread di leggere contemporaneamente, ma non fornisce il possesso esclusivo necessario per modificare dati condivisi.

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

Sintassi

#include <mutex>
#include <shared_mutex>

// Acquire shared ownership immediately:
std::shared_lock<Mutex> guard(m);

// Alternatively, defer acquisition:
// std::shared_lock<Mutex> guard(m, std::defer_lock);

std::shared_lock<Mutex> gestisce il possesso condiviso di un lock; non è il mutex stesso. Mutex deve soddisfare i requisiti di Cpp17SharedLockable. L’oggetto è spostabile, ma non copiabile. Il mutex associato deve esistere per tutto il restante ciclo di vita del guardiano, anche quando questo non possiede il lock.

La costruzione con il solo mutex chiama lock_shared() e può bloccarsi. Il distruttore chiama unlock_shared() se il guardiano possiede il lock. std::defer_lock rimanda l’acquisizione, std::try_to_lock tenta di acquisirlo senza attendere e std::adopt_lock richiede che il thread corrente possieda già il lock condiviso. Usa owns_lock() o la conversione a bool per verificare l’esito di un tentativo di acquisizione.

Con std::shared_mutex, più thread possono possedere contemporaneamente il lock condiviso; il possesso esclusivo non può coesistere con esso. Segui un protocollo coerente: letture con std::shared_lock, scritture con un lock esclusivo come std::unique_lock. Il possesso condiviso non impone l’immutabilità e non protegge da solo dalle scritture simultanee dei lettori.

unlock() rilascia un lock posseduto, mentre release() si limita a scollegare il mutex dal guardiano: non lo sblocca. Le operazioni temporizzate richiedono un mutex che soddisfi Cpp17SharedTimedLockable; std::shared_mutex non è sufficiente. L’esempio usa intenzionalmente un solo thread: la scrittura termina prima della lettura ed entrambi gli ambiti mostrano il rilascio automatico del lock.

Esempi

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

int main() {
    std::shared_mutex mutex;
    int value = 0;
    {
        std::unique_lock<std::shared_mutex> writer(mutex);
        value = 42;
    }
    {
        std::shared_lock<std::shared_mutex> reader(mutex);
        std::cout << std::boolalpha
                  << reader.owns_lock() << ' ' << value << '\n';
    }
}

Risultato

true 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