Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::shared_lock — gestionar la posesión de un bloqueo compartido

std::shared_lock de <shared_mutex> gestiona la posesión compartida de un bloqueo mediante RAII. Permite que varios hilos lean a la vez, pero no proporciona la posesión exclusiva necesaria para modificar datos compartidos.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#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> gestiona la posesión compartida de un bloqueo; no es el propio mutex. Mutex debe cumplir los requisitos de Cpp17SharedLockable. El objeto se puede mover, pero no copiar. El mutex asociado debe existir durante todo el resto de la vida del guardián, incluso cuando este no posea el bloqueo.

La construcción indicando solo un mutex llama a lock_shared() y puede bloquearse. El destructor llama a unlock_shared() si el guardián posee el bloqueo. std::defer_lock aplaza la adquisición, std::try_to_lock intenta adquirirlo sin esperar y std::adopt_lock requiere que el hilo actual ya posea el bloqueo compartido. Usa owns_lock() o la conversión a bool para comprobar el resultado de un intento de adquisición.

Con std::shared_mutex, varios hilos pueden poseer el bloqueo compartido simultáneamente; la posesión exclusiva no puede coexistir con ella. Sigue un protocolo coherente: lecturas bajo std::shared_lock y escrituras bajo un bloqueo exclusivo, como std::unique_lock. La posesión compartida no impone la inmutabilidad ni protege por sí sola frente a escrituras simultáneas de los lectores.

unlock() libera un bloqueo poseído, mientras que release() solo separa el mutex del guardián: no lo desbloquea. Las operaciones temporizadas requieren un mutex que cumpla Cpp17SharedTimedLockable; std::shared_mutex no es suficiente. El ejemplo usa deliberadamente un solo hilo: la escritura termina antes de la lectura y ambos ámbitos muestran la liberación automática del bloqueo.

Ejemplos

#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

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes