PTHREAD_COND | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
NOM | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
SYNOPSIS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
int pthread_cond_signal(pthread_cond_t *cond);
int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime);
DESCRIPTION | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Une variable condition doit toujours être associée à un mutex, pour éviter les accès concurrents où un thread se prépare à attendre une condition et un autre signale la condition juste avant que le premier n'attende réellement.
pthread_cond_init() initialise la variable condition cond, en utilisant les attributs de condition spécifiés par cond_attr, ou les attributs par défaut si cond_attr vaut NULL. L'implémentation LinuxThreads ne supporte aucun attribut de conditions, aussi le paramètre cond_attr est-il pour l'instant ignoré.
Les variables de type pthread_cond_t peuvent également être statiquement initialisées, en utilisant la constante PTHREAD_COND_INITIALIZER.
pthread_cond_signal() relance l'un des threads attendant la variable condition cond. S'il n'existe aucun thread répondant à ce critière, rien ne se produit. Si plusieurs threads attendent sur cond, seul l'un d'entre eux sera relancé, mais il est impossible de savoir lequel.
pthread_cond_broadcast() relance tous les threads attendant sur la variable condition cond. Rien ne se passe s'il n'y a aucun thread attendant sur cond.
pthread_cond_wait() déverrouille atomiquement le mutex (comme pthread_mutex_unlock(3)) et attend que la variable condition cond soit signalée. L'exécution du thread est suspendue et ne consomme pas de temps CPU jusqu'à ce que la variable condition soit signalée. Le mutex doit être verrouillé par le thread appelant à l'entrée de pthread_cond_wait(). Avant de rendre la main au thread appelant, pthread_cond_wait() reverrouille mutex (comme pthread_mutex_lock(3)).
Le déverouillage du mutex et la suspension de l'exécution sur la variable condition sont liés atomiquement. Donc, si tous les threads verrouillent le mutex avant de signaler la condition, il est garanti que la condition ne peut être signalée (et donc ignorée) entre le moment où un thread verrouille le mutex et le moment où il attend sur la variable condition.
pthread_cond_timedwait() déverrouille le mutex et attend sur cond, en liant atomiquement ces deux étapes, comme le fait pthread_cond_wait(), cependant l'attente est bornée temporellement. Si cond n'a pas été signalée après la période spécifiée par abstime, le mutex mutex est reverrouillé et pthread_cond_timedwait() rend la main avec l'erreur ETIMEDOUT. Le paramètre abstime spécifie un temps absolu, avec la même origine que time(2) et gettimeofday(2) : un abstime de 0 correspond à 00:00:00 GMT, le 1er Janvier 1970.
pthread_cond_destroy() détruit une variable condition, libérant les ressources qu'elle possède. Aucun thread ne doit attendre sur la condition à l'entrée de pthread_cond_destroy(). Dans l'implémentation LinuxThreads, aucune ressource ne peut être associée à une variable condition, aussi pthread_cond_destroy() ne fait en fait rien d'autre que vérifier qu'aucun thread n'attend la condition.
ANNULATION | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
FIABILITÉ PAR RAPPORT AUX SIGNAUX ASYNCHRONES | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
VALEUR RENVOYÉE | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
ERREURS | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
La fonction pthread_cond_timedwait() renvoie l'un des codes d'erreur suivants en cas de problème :
La fonction pthread_cond_destroy() renvoie le code d'erreur suivant en cas de problème :
EXEMPLE | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
int x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
pthread_mutex_lock(&mut); while (x <= y) { pthread_cond_wait(&cond, &mut); } /* agir sur x et y */ pthread_mutex_unlock(&mut);
Les modifications de x et y qui peuvent rendre x plus grand que y doivent signaler la condition si nécessaire :
pthread_mutex_lock(&mut); /* modifer x et y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut);
Pour attendre que x devienne plus grand que y avec un timeout de 5 secondes, faîtes :
struct timeval now; struct timespec timeout; int retcode; pthread_mutex_lock(&mut); gettimeofday(&now); timeout.tv_sec = now.tv_sec + 5; timeout.tv_nsec = now.tv_usec * 1000; retcode = 0; while (x <= y && retcode != ETIMEDOUT) { retcode = pthread_cond_timedwait(&cond, &mut, &timeout); } if (retcode == ETIMEDOUT) { /* timeout */ } else { /* agir sur x et y */ } pthread_mutex_unlock(&mut);
AUTEUR | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
VOIR AUSSI | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
TRADUCTION | Début | Précédent | Suivant | Sommaire | Préc.page.lue | Accueil |
Ce document est une traduction réalisée par Thierry Vignaud <tvignaud AT mandriva DOT com> en 2000 et révisée le 25 avril 2008.
L'équipe de traduction a fait le maximum pour réaliser une adaptation française de qualité. La version anglaise la plus à jour de ce document est toujours consultable via la commande : « LANG=C man 3 pthread_cond_init ». N'hésitez pas à signaler à l'auteur ou au traducteur, selon le cas, toute erreur dans cette page de manuel.
Sommaire | Début | Suivant | Sommaire | Préc.page.lue | Accueil |