◆ Realización de bloqueo de lectura-escritura
typedef boost::shared_lock<boost::shared_mutex> readLock;
typedef boost:: unique_lock<boost::shared_mutex> writeLock;
boost::shared_mutex rwmutex;
void readOnly( )
{
readLock rdlock( rwmutex );
/// do something
}
void writeOnly( )
{
writeLock wtlock( rwmutex );
/// do something
}
Para el mismo rwmutex, los subprocesos pueden tener varios readLocks al mismo tiempo. Estos readLocks bloquearán cualquier subproceso que intente obtener writeLock hasta que se destruyan todos los objetos readLock. Si writeLock obtiene rwmutex primero, bloqueará cualquier hilo que intente obtener readLock o writeLock en rwmutex.
▼ mutex recursivo
boost :: recursive_mutex proporciona un mutex recursivo. Por ejemplo, como máximo un subproceso puede mantener su bloqueo. Si un subproceso ha bloqueado una instancia boost :: recursive_mutex, entonces este subproceso puede bloquear esta instancia varias veces.
lock_guard solo se puede usar como se indicó anteriormente, mientras que unique_lock permite establecer un tiempo de espera, posponer el bloqueo del bloqueo y el desbloqueo antes de que se destruya el objeto.
{
boost::unique_lock<boost::mutex> lk( m );
process( data );
lk.unlock( );
// do other thing
};
★ Establecer tiempo de espera de bloqueo
boost :: unique_lockboost :: timed_mutex lk (m, std :: chrono :: milisegundos (3)); // tiempo de espera de 3 segundos
if (lk) proceso (datos);
◆ upgrade_lock
Qué es upgrade_lock, su característica más importante es que no es mutuamente excluyente con shared_lock, y mutuamente excluyente con otros upgrade_lock y unique_lock. Es decir, después de que el subproceso A obtiene el upgrade_lock del mutex, los subprocesos B, C, etc. también pueden obtener el share_mutex del mutex, y viceversa.
No se limita a los candados exclusivos proporcionados por pares bloqueables, sino que también admite candados actualizables.
Nota:
Cuando el código del bloqueo de escritura está anidado con el código del bloqueo de lectura, se producirá un interbloqueo. ! ! Los ejemplos son los siguientes:
boost::shared_mutex m_mutex;
void test()
{
boost::shared_lock<boost::shared_mutex> ReadLock(m_mutex);
}
int main()
{
...................................
boost::unique_lock<boost::shared_mutex> WriteLock(m_mutex);
....................................
{
test();
}
....................................
}
Dado que el bloqueo se ha adquirido en main, si desea volver a adquirir el bloqueo de lectura al ejecutar test (), debe esperar a que se libere el bloqueo de escritura en main. Pero el bloqueo de escritura no se liberará y el bloqueo de lectura en la prueba esperará eternamente.