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

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.

Fontes