CKTIS / C++
std::shared_mutex — bloqueio partilhado e exclusivo
std::shared_mutex permite que várias threads detenham simultaneamente o bloqueio partilhado, ou que uma só thread detenha o bloqueio exclusivo. Use std::shared_lock para leitura e std::unique_lock para escrita, seguindo o mesmo protocolo em cada acesso aos dados protegidos.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#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, declarado em <shared_mutex>, é um mutex não recursivo. O modo partilhado permite vários detentores ao mesmo tempo; o modo exclusivo exclui todos os outros detentores. O protocolo habitual consiste em ler com detenção partilhada e modificar com detenção exclusiva. O mutex, por si só, não controla o acesso às variáveis: o código tem de seguir este protocolo de forma consistente.
lock() e unlock() gerem a detenção exclusiva, enquanto lock_shared() e unlock_shared() gerem a detenção partilhada. As operações bloqueantes aguardam até ser possível adquirir a detenção. try_lock() e try_lock_shared() tentam adquiri-la sem esperar e devolvem bool; podem falhar espuriamente, pelo que false não prova que outra thread detenha o mutex.
Prefira RAII ao desbloqueio manual: use std::shared_lock<std::shared_mutex> de <shared_mutex> para leitores e std::unique_lock<std::shared_mutex> de <mutex> para escritores. Estes objetos libertam o bloqueio detido quando o respetivo âmbito termina, incluindo durante a propagação de uma exceção. A detenção partilhada não proporciona a exclusividade necessária para modificar normalmente dados partilhados.
Não tente adquirir novamente qualquer dos tipos de detenção numa thread que já detenha o mesmo mutex: o comportamento é indefinido. Isto inclui tentar adquirir a detenção exclusiva sem libertar a partilhada. Desbloquear e voltar a bloquear não é uma mudança de modo atómica — os dados podem mudar entretanto. Não destrua um mutex detido nem deixe uma thread terminar enquanto ainda o detém.
O exemplo separa a escrita da leitura através de join() e protege cada acesso a value com o bloqueio adequado. Os leitores podem ser executados em simultâneo, mas não têm de o ser; guardam os resultados em variáveis distintas. A impressão após ambas as chamadas a join() produz o resultado determinístico 42 42.
Exemplos
#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';
}
Resultado
42 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.
Fontes
- C++ working draft — Concurrency support library [thread]
- C++ working draft — Class shared_mutex [thread.sharedmutex.class]
- C++ working draft — Shared mutex types [thread.sharedmutex.requirements]
- C++ working draft — Class template shared_lock [thread.lock.shared]
- C++ working draft — Class template unique_lock [thread.lock.unique]