Comportamiento EventWaitHandle para pthread_cond_t

Question

Recientemente he visto la luz del comportamiento poderoso de EventWaitHandle en C # y decidí mover alguna funcionalidad en una aplicación hermana para hacer lo mismo. El único problema es que la aplicación hermana está escrita en C.

No es gran cosa, estoy usando pthreads, que tienen un tipo de datos pthread_cond_t que permite la señalización. Mi única pregunta es, ¿es posible que un cond sea 'señalado' antes de que algo lo esté esperando?

En este momento mi prueba dice que no. Es decir, si ThreadA dispara una señal antes de que ThreadB esté esperando, ThreadB esperará indefinidamente. ¿Hay otro tipo de pthread que pueda usar que se comporte más cerca de la funcionalidad de EventWaitHandle en C #? Se señala un objeto, lo que significa que el primer subproceso que lo espere, pasará de inmediato y lo configurará como no identificado.

No sería tan difícil lograr esto con pthread_cond en otra estructura de datos. Pero, de nuevo, ¿esta funcionalidad ya está disponible en la biblioteca pthread?

Answer 1

Si estás usando las variables de condición correctamente, esto no importará.

El flujo básico de su código debe ser (en pseudocódigo):

lock(lockobj);
while (!signalled) {
    wait(condvar);
}
signalled = false;
unlock(lockobj);

en el lado de espera, y:

lock(lockobj);
signalled = true;
notify(condvar);
unlock(lockobj);

en el lado de señalización. (Por supuesto, el objeto de bloqueo y la variable de condición utilizada deben ser iguales en ambos lados.) ¡Espero que esto ayude!

Answer 2

Respuesta alternativa (también en pseudocódigo) si desea múltiples señalizaciones (es decir, si se señala dos veces, entonces dos hilos pueden esperar antes de que el estado vuelva a estar sin firmar).

Lado de espera:

lock(lockobj);
while (signalled != 0) {
    wait(condvar);
}
--signalled;
unlock(lockobj);

lado de señalización:

lock(lockobj);
++signalled;
notify(condvar);
unlock(lockobj);

Answer 3

Terminé simplemente envolviendo un tipo de condición en una nueva estructura y creé algunas funciones simples que se comportan de manera muy parecida a EventWaitHandle de C #. Necesitaba dos mutexes para lograr un acceso serializado adecuado.

El cond_mutex se usa para esperar en la variable condicional, mientras que el data_mutex se usa cuando se configura el estado de señalizado a no señalizado.

El modo de reinicio es el mismo desde C #. AUTO o MANUAL. Esto permite que el event_wait_t se reinicie automáticamente después de esperar. O dejar que el programador lo haga manualmente con una llamada a event_wait_reset (event_wait_t * ewh);