Comportement EventWaitHandle pour pthread_cond_t

Question

J'ai récemment vu la lumière du puissant comportement de EventWaitHandle en C # et décidé de déplacer certaines fonctionnalités d'une application soeur pour faire de même. Le seul problème est que l'application sœur est écrite en C.

Pas de problème, j'utilise des pthreads, qui ont un type de données pthread_cond_t permettant la signalisation. Ma seule question est la suivante: est-il possible de "signaler" un cond avant qu'il ne soit en attente?

En ce moment, mes tests disent non. C'est-à-dire que si ThreadA envoie un signal avant que ThreadB soit en attente, ThreadB attend indéfiniment. Existe-t-il un autre type de pthread que je peux utiliser qui se comporte de manière plus proche de la fonctionnalité de EventWaitHandle en C #? Un objet est signalé, c’est-à-dire que le premier thread à attendre dessus passera immédiatement et le définira sur non-signalé.

Intégrer le pthread_cond dans une autre structure de données ne serait pas trop difficile à réaliser. Mais encore une fois, cette fonctionnalité est-elle déjà disponible dans la bibliothèque pthread?

Answer 1

Si vous utilisez les variables de condition correctement, cela n'aura pas d'importance.

Le flux de base de votre code devrait être (en pseudocode):

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

du côté de l'attente, et:

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

du côté de la signalisation. (Bien entendu, l'objet de verrouillage et la variable de condition utilisée doivent être identiques des deux côtés.) J'espère que cela vous aidera!

Answer 2

Réponse alternative (également en pseudo-code) si vous souhaitez plusieurs signalisations (c'est-à-dire, si elles sont signalées deux fois, deux threads peuvent attendre avant que l'état ne soit à nouveau non-signalé).

Côté attente:

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

Côté de signalisation:

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

Answer 3

J'ai fini par envelopper un type de condition dans une nouvelle structure et créé quelques fonctions simples qui se comportaient de la même manière que EventWaitHandle de C #. J'avais besoin de deux mutex pour obtenir un accès sérialisé approprié.

Le cond_mutex est utilisé pour attendre la variable conditionnelle, tandis que le data_mutex est utilisé lors de la définition de l'état signalé à non signalé.

Le mode de réinitialisation est identique à celui de C #. AUTO ou MANUEL. Cela permet à event_wait_t de se réinitialiser automatiquement après avoir attendu. Ou laisser le programmeur le faire manuellement avec un appel à event_wait_reset (event_wait_t * ewh);