CKTIS / C++
std::shared_lock — gerir a posse partilhada de um bloqueio
std::shared_lock de <shared_mutex> gere a posse partilhada de um bloqueio através de RAII. Permite que várias threads leiam em simultâneo, mas não fornece a posse exclusiva necessária para modificar dados partilhados.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#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> gere a posse partilhada de um bloqueio; não é o próprio mutex. Mutex tem de cumprir os requisitos de Cpp17SharedLockable. O objeto pode ser movido, mas não copiado. O mutex associado tem de existir durante todo o restante tempo de vida do guardião, mesmo quando este não possui o bloqueio.
A construção apenas com um mutex chama lock_shared() e pode bloquear. O destrutor chama unlock_shared() se o guardião possuir o bloqueio. std::defer_lock adia a aquisição, std::try_to_lock tenta adquiri-lo sem esperar e std::adopt_lock exige que a thread atual já possua o bloqueio partilhado. Usa owns_lock() ou a conversão para bool para verificar o resultado de uma tentativa de aquisição.
Com std::shared_mutex, várias threads podem possuir simultaneamente o bloqueio partilhado; a posse exclusiva não pode coexistir com ela. Segue um protocolo consistente: leituras com std::shared_lock e escritas com um bloqueio exclusivo, como std::unique_lock. A posse partilhada não impõe imutabilidade nem protege, por si só, contra escritas simultâneas dos leitores.
unlock() liberta um bloqueio possuído, enquanto release() apenas desassocia o mutex do guardião — não o desbloqueia. As operações temporizadas exigem um mutex que cumpra Cpp17SharedTimedLockable; std::shared_mutex não é suficiente. O exemplo usa deliberadamente uma só thread: a escrita termina antes da leitura e ambos os âmbitos demonstram a libertação automática do bloqueio.
Exemplos
#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';
}
}
Resultado
true 42
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.