Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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