Recuperando pthread_cond_t y pthread_mutex_t después de la terminación del proceso.

Hola!

Ya he buscado problemas similares aquí, pero no llegué a una solución final.

En mi aplicación, tengo dos procesos que se ejecutan simultáneamente que necesitan estar sincronizados a través de la memoria compartida. Actualmente estoy utilizando un pthread_mutex_t y un pthread_cond_t con ese propósito, que se colocan en memoria compartida.

Esto funciona bien hasta que el proceso A falla mientras espera en la condición. Si se reinicia el proceso A, se produce un bloqueo (¿?) en el que el proceso A espera en la condición y el proceso B queda atascado indefinidamente en la llamada a pthread_cond_broadcast.

Leí que esto puede deberse al mutex que está en un estado inconsistente, pero de hecho nunca parece estar en mi programa.
Agradecería que me dijeras si malinterpreté algo o si hay enfoques alternativos para resolver esto o si no es posible proteger este caso de bloqueo.

“` lang-c ++
estructura Poller
{
privado:
std::atómico a la espera;
pthreadmutext mtx;
pthreadcondt cnd;

bloquearMutex automático () -> void
{
// Recuperar Mutex si algún proceso que lo bloquea murió inesperadamente
LOG_DEBUG (info, “AdaptivePoller”, “Bloqueo de mutex…”);
si (pthread_mutex_lock (&mtx) == EOWNERDEAD) {
LOG_DEBUG (info, “AdaptivePoller”, “Mutex en estado inconsistente.”);
si (pthread_mutex_consistent (&mtx)! = 0) {
lanzar std :: runtime_error (“No se pudo devolver el mutex a un estado consistente.”);
}
}
}

público:
Poller()
{
a la espera = falso;

pthread_mutexattr_t attr;
pthread_mutexattr_init (&attr);
pthread_mutexattr_setrobust (&attr, PTHREAD_MUTEX_ROBUST);
pthread_mutexattr_setpshared (&attr, PTHREAD_PROCESS_SHARED);
pthread_mutex_init (&mtx, &attr);
pthread_mutexattr_destroy (&attr);

pthread_condattr_t attrcond;
pthread_condattr_init (&attrcond);
pthread_condattr_setpshared (&attrcond, PTHREAD_PROCESS_SHARED);
pthread_cond_init (&cnd, &attrcond);
pthread_condattr_destroy (&attrcond);

}

auto esperar() -> void
{
bloquearMutex();
a la espera = verdadero;
LOG_DEBUG (info, “AdaptivePoller”, “Comenzar a esperar…”);
mientras (esperar) {
pthread_cond_wait (&cnd, &mtx);
}
pthread_mutex_unlock (&mtx);
}

auto notificar() -> void
{
bloquearMutex();
a la espera = falso;
LOG_DEBUG (info, “AdaptivePoller”, “Notificación…”);
pthread_cond_broadcast (&cnd);
pthread_mutex_unlock (&mtx);
}

};