Attendre sur de multiples variables de condition sur Linux sans inutiles dort-il?

Si vous parlez des threads POSIX je vous recommande d'utiliser une seule variable d'état et le nombre de cas de drapeaux ou quelque chose de semblable. L'idée est d'utiliser le peer condvar mutex pour la garde des notifications d'événements. Toute façon, vous devez vérifier pour les événements d'après cond_wait() de sortie. Voici mon ancien assez de code pour illustrer ce de ma formation (oui, j'ai vérifié qu'il fonctionne, mais s'il vous plaît noter qu'il a été préparé il y a quelques temps et pressé pour les nouveaux arrivants).

#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
static pthread_cond_t var;
static pthread_mutex_t mtx;
unsigned event_flags = 0;
#define FLAG_EVENT_1    1
#define FLAG_EVENT_2    2
void signal_1()
{
pthread_mutex_lock(&mtx);
event_flags |= FLAG_EVENT_1;
pthread_cond_signal(&var);
pthread_mutex_unlock(&mtx);
}
void signal_2()
{
pthread_mutex_lock(&mtx);
event_flags |= FLAG_EVENT_2;
pthread_cond_signal(&var);
pthread_mutex_unlock(&mtx);
}
void* handler(void*)
{
//Mutex is unlocked only when we wait or process received events.
pthread_mutex_lock(&mtx);
//Here should be race-condition prevention in real code.
while(1)
{
if (event_flags)
{
unsigned copy = event_flags;
//We unlock mutex while we are processing received events.
pthread_mutex_unlock(&mtx);
if (event_flags & FLAG_EVENT_1)
{
printf("EVENT 1\n");
event_flags ^= FLAG_EVENT_1;
}
if (event_flags & FLAG_EVENT_2)
{
printf("EVENT 2\n");
event_flags ^= FLAG_EVENT_2;
//And let EVENT 2 is signal to close.
//In this case for consistency we break with locked mutex.
pthread_mutex_lock(&mtx);
break;
}
//Note we should have mutex locked at the iteration end.
pthread_mutex_lock(&mtx);
}
else
{
//Mutex is locked. It is unlocked while we are waiting.
pthread_cond_wait(&var, &mtx);
//Mutex is locked.
}
}
//... as we are dying.
pthread_mutex_unlock(&mtx);
}
int main()
{
pthread_mutex_init(&mtx, NULL);
pthread_cond_init(&var, NULL);
pthread_t id;
pthread_create(&id, NULL, handler, NULL);
sleep(1);
signal_1();
sleep(1);
signal_1();
sleep(1);
signal_2();
sleep(1);
pthread_join(id, NULL);
return 0;
}

Si vous voulez un maximum de flexibilité en vertu de la POSIX variable d'état du modèle de synchronisation, vous devez éviter d'écrire des modules qui communiquent les événements à leurs utilisateurs que par le biais de l'exposition d'une variable de condition. (Vous avez alors essentiellement réinventé un sémaphore.)

Active les modules doivent être conçus de telle sorte que leurs interfaces fournissent des notifications de rappel d'événements, via enregistrés fonctions: et, si nécessaire, de telle sorte que plusieurs rappels peuvent être enregistrés.

Un client de plusieurs modules enregistre un rappel avec chacun d'eux. Toutes ces valeurs peuvent être acheminés dans un endroit commun où ils verrouillage de la même mutex, changement de l'état, déverrouiller, et frappé de la même variable de condition.

Cette conception offre également la possibilité que, si la quantité de travail effectué en réponse à un événement est raisonnablement petit, peut-être qu'il peut seulement être fait dans le contexte de la fonction de rappel.

Rappels ont aussi quelques avantages dans le débogage. Vous pouvez mettre un point d'arrêt sur un événement qui arrive sous la forme d'un rappel, et de voir la pile d'appels de la façon dont il a été généré. Si vous mettez un point d'arrêt sur un événement qui arrive comme un sémaphore de réveil, ou par l'intermédiaire de la transmission de message mécanisme, la trace d'appel de ne pas révéler l'origine de l'événement.

Cela étant dit, vous pouvez faire votre propre primitives de synchronisation avec les mutex et les variables de condition, de soutien en attente sur plusieurs objets. Ces primitives de synchronisation peut être en interne basé sur les rappels, d'une manière qui est invisible pour le reste de l'application.

L'essentiel, c'est que, pour chaque objet, qu'un thread souhaite attendre, l'attente fonctionnement des files d'attente d'une interface de rappel avec cet objet. Lorsqu'un objet est signalé, il appelle tous ses rappels enregistrés. L'réveillé fils résorption de toutes les interfaces de rappel, et coup d'oeil à certains indicateurs d'état dans chacun de voir quels sont les objets signalés.