CKTIS / C++
std::shared_mutex — bloqueo compartido y exclusivo
std::shared_mutex permite que varios hilos tengan el bloqueo compartido a la vez, o que un solo hilo tenga el bloqueo exclusivo. Usa std::shared_lock para leer y std::unique_lock para escribir, siguiendo el mismo protocolo en cada acceso a los datos protegidos.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#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 en <shared_mutex>, es un mutex no recursivo. El modo compartido permite varios propietarios a la vez; el modo exclusivo excluye a todos los demás. El protocolo habitual consiste en leer con propiedad compartida y modificar con propiedad exclusiva. El mutex no controla por sí mismo el acceso a las variables: el código debe seguir ese protocolo de forma coherente.
lock() y unlock() gestionan la propiedad exclusiva, mientras que lock_shared() y unlock_shared() gestionan la compartida. Las operaciones bloqueantes esperan hasta que se pueda adquirir la propiedad. try_lock() y try_lock_shared() intentan adquirirla sin esperar y devuelven bool; pueden fallar de forma espuria, por lo que false no demuestra que otro hilo tenga el mutex.
Es preferible usar RAII en lugar de desbloquear manualmente: utiliza std::shared_lock<std::shared_mutex> de <shared_mutex> para los lectores y std::unique_lock<std::shared_mutex> de <mutex> para los escritores. Estos objetos liberan el bloqueo que poseen al salir de su ámbito, también durante la propagación de una excepción. La propiedad compartida no proporciona la exclusividad necesaria para modificar normalmente datos compartidos.
No intentes volver a adquirir ninguno de los tipos de propiedad en un hilo que ya posee el mismo mutex: el comportamiento es indefinido. Esto incluye intentar adquirir la propiedad exclusiva sin liberar la compartida. Desbloquear y volver a bloquear no es un cambio de modo atómico: los datos pueden cambiar mientras tanto. No destruyas un mutex que esté en posesión de un hilo ni permitas que un hilo termine mientras todavía lo posee.
El ejemplo separa la escritura de la lectura mediante join() y protege cada acceso a value con el bloqueo adecuado. Los lectores pueden ejecutarse simultáneamente, pero no es obligatorio; guardan los resultados en variables distintas. Imprimir después de las dos llamadas a join() produce el resultado determinista 42 42.
Ejemplos
#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
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
- 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]