Bloqueo lector-escritor

En informática , un bloqueo de lectura-escritura ( bloqueo de escritura única , ^{[ 1 ]} bloqueo de lectura múltiple , ^{[ 2 ]} bloqueo de inserción , ^{[ 3 ]} o bloqueo MRSW ) es una primitiva de sincronización que resuelve uno de los problemas de lectura-escritura . Un bloqueo RW permite el acceso concurrente para operaciones de solo lectura, mientras que las operaciones de escritura requieren acceso exclusivo. Esto significa que varios hilos pueden leer los datos en paralelo, pero se necesita un bloqueo exclusivo para escribir o modificar datos. Cuando un escritor está escribiendo los datos, todos los demás escritores y lectores se bloquearán hasta que el escritor termine de escribir. Un uso común podría ser controlar el acceso a una estructura de datos en memoria que no se puede actualizar atómicamente y es inválida (y no debe ser leída por otro hilo) hasta que la actualización se complete.

Los bloqueos de lectura-escritura generalmente se construyen sobre mutexes y variables de condición , o sobre semáforos .

Algunos bloqueos RW permiten actualizar atómicamente el bloqueo de modo de lectura a modo de escritura, así como degradarlo de modo de escritura a modo de lectura. ^{[ 4 ]} La actualización de un bloqueo de modo de lectura a modo de escritura es propensa a interbloqueos, ya que cuando dos hilos que poseen bloqueos de lectura intentan actualizarse a bloqueos de escritura, se crea un interbloqueo que solo puede romperse si uno de los hilos libera su bloqueo de lectura. El interbloqueo puede evitarse permitiendo que solo un hilo adquiera el bloqueo en "modo de lectura con la intención de actualizarse a escritura" mientras no haya hilos en modo de escritura y posiblemente no haya hilos en modo de lectura.

Los bloqueos RW pueden diseñarse con distintas políticas de prioridad para el acceso de lectores y escritores. El bloqueo puede diseñarse para dar siempre prioridad a los lectores ( preferencia de lectura ), para dar siempre prioridad a los escritores ( preferencia de escritura ) o no especificar ninguna prioridad. Estas políticas conllevan diferentes ventajas y desventajas en cuanto a la concurrencia y la inanición .

• Los bloqueos RW con preferencia de lectura permiten la máxima concurrencia, pero pueden provocar inanición de escritura si la contención es alta. Esto se debe a que los hilos de escritura no podrán adquirir el bloqueo mientras al menos un hilo de lectura lo mantenga. Dado que varios hilos de lectura pueden mantener el bloqueo simultáneamente, esto significa que un hilo de escritura puede seguir esperando el bloqueo mientras nuevos hilos de lectura pueden adquirirlo, incluso hasta el punto de que el escritor puede seguir esperando después de que todos los lectores que lo mantenían cuando intentó adquirirlo por primera vez lo hayan liberado. La prioridad para los lectores puede ser débil , como se acaba de describir, o fuerte , lo que significa que cada vez que un escritor libera el bloqueo, cualquier lector bloqueador lo adquiere a continuación. ^{[ 5 ] : 76}
• Los bloqueos RW con preferencia de escritura evitan el problema de la inanición de escritores al impedir que nuevos lectores adquieran el bloqueo si hay un escritor en cola esperando; el escritor adquirirá el bloqueo tan pronto como todos los lectores que ya lo poseían hayan finalizado. ^{[ 6 ]} La desventaja es que los bloqueos con preferencia de escritura permiten una menor concurrencia en presencia de hilos escritores, en comparación con los bloqueos RW con preferencia de lectura. Además, el rendimiento del bloqueo es menor porque cada operación, ya sea tomar o liberar el bloqueo para lectura o escritura, es más compleja, requiriendo internamente tomar y liberar dos mutex en lugar de uno. Esta variación también se conoce a veces como bloqueo lector-escritor con "sesgo de escritura". ^{[ 7 ]}
• Los bloqueos RW de prioridad no especificada no ofrecen ninguna garantía en cuanto al acceso de lectura frente al de escritura. En algunas situaciones, la prioridad no especificada puede ser preferible si permite una implementación más eficiente.

Existen diversas estrategias de implementación para los bloqueos de lectores y escritores, que los reducen a primitivas de sincronización que se presuponen preexistentes.

Establece b en 0. r está desbloqueado. g está desbloqueado.

Bloquear r . Incremento b . Si b = 1 , bloquea g . Desbloquear r .

Bloquear r . Disminución b . Si b = 0 , desbloquea g . Desbloquear r .

Bloquear g .

Desbloquear g .

Bloquear g Mientras num_writers_waiting > 0 o writer_active : esperar cond , g [ a ] Incrementar num_readers_active Desbloquear g .

Bloquear g Decrementar num_readers_active Si num_readers_active = 0 : Notificar condición (difusión) Desbloquear g .

Bloquear g Incrementar num_writers_waiting Mientras num_readers_active > 0 o writer_active sea verdadero : esperar cond , g Decrementar num_writers_waiting Establecer writer_active en verdadero Desbloquear g .

Bloquear g Establecer writer_active en falso Notificar cond (difusión) Desbloquear g .

• Estándar POSIXpthread_rwlock_t y operaciones asociadas ^{[ 11 ]}
• Interfaz ReadWriteLock ^{[ 12 ]} y bloqueos ReentrantReadWriteLock ^{[ 7 ]} en Java versión 5 o superior
• System.Threading.ReaderWriterLockSlimBloqueo de Microsoft para C# y otros lenguajes .NET ^{[ 13 ]}
• std::shared_mutexbloqueo de lectura/escritura en C++17 ^{[ 14 ]}
• boost::shared_mutexy boost::upgrade_mutexbloqueos en las bibliotecas Boost C++ ^{[ 15 ]}
• SRWLock, añadido a la API del sistema operativo Windows a partir de Windows Vista . ^{[ 16 ]}
• sync.RWMutexen Go ^{[ 17 ]}
• bloqueo lector-escritor justo de fase, que alterna entre lectores y escritores ^{[ 18 ]}
• std::sync::RwLockbloqueo de lectura/escritura en Rust ^{[ 19 ]}
• Poco::RWBloquear en las bibliotecas POCO C++
• mse::recursive_shared_timed_mutexEn la biblioteca SaferCPlusPlusstd::shared_timed_mutex hay una versión que admite la semántica de propiedad recursiva de std::recursive_mutex.
• txrwlock.ReadersWriterDeferredLockBloqueo de lectores/escritores para Twisted ^{[ 20 ]}
• rw_semaphoreen el núcleo de Linux ^{[ 21 ]}

usar std :: sync :: RwLock ;let lock = RwLock :: new ( 5 );// Se pueden mantener varios bloqueos de lectura a la vez { let r1 = lock . read (). unwrap (); let r2 = lock . read (). unwrap (); assert_eq! ( * r1 , 5 ); assert_eq! ( * r2 , 5 ); } // Los bloqueos de lectura se liberan en este punto// Solo se puede mantener un bloqueo de escritura, sin embargo { let mut w = lock . write (). unwrap (); * w += 1 ; assert_eq! ( * w , 6 ); } // El bloqueo de escritura se libera aquí

El algoritmo de lectura-copia-actualización (RCU) es una solución al problema de lectores-escritores. RCU no requiere esperas para los lectores. El kernel de Linux implementa una solución especial para algunos escritores llamada seqlock .

• Semáforo (programación)
• Exclusión mutua
• Patrón de planificador
• Patrón de resistencia
• Bloqueo de archivos
• Bloqueo (informática)
• El problema de los lectores y escritores