¿Ejemplo de boostshared_mutex (múltiples lecturas/una escritura)?
Tengo una aplicación multiproceso que tiene que leer algunos datos con frecuencia y, ocasionalmente, esos datos se actualizan. En este momento, un mutex mantiene seguro el acceso a esos datos, pero es costoso porque me gustaría que varios subprocesos pudieran leer simultáneamente y solo bloquearlos cuando se necesita una actualización (el subproceso de actualización podría esperar a que finalicen los otros subprocesos). .
Creo que esto es lo que boost::shared_mutexse supone que debe hacer, pero no tengo claro cómo usarlo y no he encontrado un ejemplo claro.
¿Alguien tiene un ejemplo sencillo que pueda utilizar para empezar?
1800 INFORMACIÓN es más o menos correcta, pero hay algunos problemas que quería corregir.
boost::shared_mutex _access;
void reader()
{
boost::shared_lock< boost::shared_mutex > lock(_access);
// do work here, without anyone having exclusive access
}
void conditional_writer()
{
boost::upgrade_lock< boost::shared_mutex > lock(_access);
// do work here, without anyone having exclusive access
if (something) {
boost::upgrade_to_unique_lock< boost::shared_mutex > uniqueLock(lock);
// do work here, but now you have exclusive access
}
// do more work here, without anyone having exclusive access
}
void unconditional_writer()
{
boost::unique_lock< boost::shared_mutex > lock(_access);
// do work here, with exclusive access
}
También tenga en cuenta que, a diferencia de un bloqueo_compartido, solo un subproceso puede adquirir un bloqueo de actualización a la vez, incluso cuando no está actualizado (lo que pensé que era incómodo cuando lo encontré). Entonces, si todos sus lectores son escritores condicionales, necesita encontrar otra solución.
Parece que harías algo como esto:
boost::shared_mutex _access;
void reader()
{
// get shared access
boost::shared_lock<boost::shared_mutex> lock(_access);
// now we have shared access
}
void writer()
{
// get upgradable access
boost::upgrade_lock<boost::shared_mutex> lock(_access);
// get exclusive access
boost::upgrade_to_unique_lock<boost::shared_mutex> uniqueLock(lock);
// now we have exclusive access
}
Desde C++ 17 (VS2015) puedes usar el estándar para bloqueos de lectura y escritura:
#include <shared_mutex>
typedef std::shared_mutex Lock;
typedef std::unique_lock< Lock > WriteLock;
typedef std::shared_lock< Lock > ReadLock;
Lock myLock;
void ReadFunction()
{
ReadLock r_lock(myLock);
//Do reader stuff
}
void WriteFunction()
{
WriteLock w_lock(myLock);
//Do writer stuff
}
Para versiones anteriores, puedes usar boost con la misma sintaxis:
#include <boost/thread/locks.hpp>
#include <boost/thread/shared_mutex.hpp>
typedef boost::shared_mutex Lock;
typedef boost::unique_lock< Lock > WriteLock;
typedef boost::shared_lock< Lock > ReadLock;
