pthread_cond_init(3) Library Functions Manual pthread_cond_init(3) NOM pthread_cond_init, pthread_cond_signal, pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait, pthread_cond_destroy - Operations sur les conditions SYNOPSIS #include 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); int pthread_cond_destroy(pthread_cond_t *cond); DESCRIPTION Une condition (abreviation pour << variable condition >>) est un mecanisme de synchronisation permettant a un thread de suspendre son execution jusqu'a ce qu'une certaine condition (un predicat) sur des donnees partagees soit verifiee. Les operations fondamentales sur les conditions sont : signaler la condition (quand le predicat devient vrai) et attendre la condition en suspendant l'execution du thread jusqu'a ce qu'un autre thread signale la condition. Une variable condition doit toujours etre associee a un mutex, pour eviter une condition concurrente ou un thread se prepare a attendre une condition et un autre thread signale la condition juste avant que le premier n'attende reellement. pthread_cond_init() initialise la variable condition cond, en utilisant les attributs de condition specifies par cond_attr, ou les attributs par defaut si cond_attr vaut NULL. L'implementation LinuxThreads ne supporte aucun attribut de condition, aussi le parametre cond_attr est pour l'instant ignore. Les variables de type pthread_cond_t peuvent egalement etre statiquement initialisees, 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 repondant a ce critere, rien ne se produit. Si plusieurs threads attendent sur cond, seul l'un d'entre eux sera relance, 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() deverrouille atomiquement le mutex (comme pthread_unlock_mutex()) et attend que la variable condition cond soit signalee. L'execution du thread est suspendue et ne consomme pas de temps CPU jusqu'a ce que la variable condition soit signalee. Le mutex doit etre verrouille par le thread appelant a l'entree de pthread_cond_wait(). Avant de rendre la main au thread appelant, pthread_cond_wait() reverrouille mutex (comme pthread_lock_mutex()). Le deverrouillage du mutex et la suspension de l'execution sur la variable condition sont lies atomiquement. Donc, si tous les threads verrouillent le mutex avant de signaler la condition, il est garanti que la condition ne peut etre signalee (et donc ignoree) entre le moment ou un thread verrouille le mutex et le moment ou il attend sur la variable condition. pthread_cond_timedwait() deverrouille le mutex et attend sur cond, en liant atomiquement ces deux etapes, comme le fait pthread_cond_wait(), cependant l'attente est bornee temporellement. Si cond n'a pas ete signalee apres la periode specifiee par abstime, le mutex mutex est reverrouille et pthread_cond_timedwait() rend la main avec l'erreur ETIMEDOUT. Le parametre abstime specifie un temps absolu, avec la meme origine que time(2) et gettimeofday(2) : un abstime de 0 correspond a 00:00:00 GMT, le 1er Janvier 1970. pthread_cond_destroy() detruit une variable condition, liberant les ressources qu'elle possede. Aucun thread ne doit attendre sur la condition a l'entree de pthread_cond_destroy(). Dans l'implementation LinuxThreads, aucune ressource ne peut etre associee a une variable condition, aussi pthread_cond_destroy() ne fait en fait rien d'autre que verifier qu'aucun thread n'attend la condition. ANNULATION pthread_cond_wait() et pthread_cond_timedwait() sont des points d'annulation. Si un thread est annule alors qu'il est suspendu dans l'une de ces fonctions, son execution reprend immediatement, reverrouillant le parametre mutex a pthread_cond_wait() et pthread_cond_timedwait(), et execute finalement l'annulation. Aussi, les gestionnaires d'annulation sont assures que mutex est verrouille lorsqu'ils sont executes. ASYNC-SIGNAL SAFETY Ces fonctions ne sont pas fiables par rapport aux signaux asynchrones et ne doivent donc pas etre utilisees dans des gestionnaires de signaux [NdT : sous peine de perdre leur propriete d'atomicite]. En particulier, appeler pthread_cond_signal() ou pthread_cond_broadcast() dans un gestionnaire de signal peut placer le thread appelant dans une situation de blocage definitif. VALEUR RENVOYEE Toutes ces fonctions renvoient 0 en cas de succes et un code d'erreur non nul en cas de probleme. ERREURS pthread_cond_init(), pthread_cond_signal(), pthread_cond_broadcast() et pthread_cond_wait() ne renvoient jamais de code d'erreur. La fonction pthread_cond_timedwait() renvoie l'un des codes d'erreur suivants en cas de probleme : ETIMEDOUT La variable condition n'a pas recu de signal avant le delai specifie par abstime. EINTR pthread_cond_timedwait() a ete interrompu par un signal. La fonction pthread_cond_destroy() renvoie le code d'erreur suivant en cas de probleme : EBUSY Il existe des threads attendant cond. VOIR AUSSI pthread_condattr_init(3), pthread_mutex_lock(3), pthread_mutex_unlock(3), gettimeofday(2), nanosleep(2) EXEMPLE Considerons deux variables globales partagees x et y, protegees par le mutex mut, et une variable condition cond pour signaler que x devient plus grand que y. int x,y; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER; Attendre que x devienne plus grand que y se realise de la maniere suivante : pthread_mutex_lock(&mut); while (x <= y) { pthread_cond_wait(&cond, &mut); } /* operate on x and y */ pthread_mutex_unlock(&mut); Les modifications de x et y qui peuvent rendre x plus grand que y doivent signaler la condition si necessaire : pthread_mutex_lock(&mut); /* modify x and y */ if (x > y) pthread_cond_broadcast(&cond); pthread_mutex_unlock(&mut); S'il peut etre prouve qu'au plus un thread en attente necessite d'etre reveille (par exemple, s'il n'y a que deux threads communiquant via x et y), pthread_cond_signal() peut etre utilise en tant qu'alternative efficace a pthread_cond_broadcast(). En cas de doute, utilisez pthread_cond_broadcast(). Pour attendre que x devienne plus grand que y avec un delai de 5 secondes, faites : 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 occurred */ } else { /* operate on x and y */ } pthread_mutex_unlock(&mut); TRADUCTION La traduction francaise de cette page de manuel a ete creee par Gerard Delafond , Christophe Blaess , Thierry Vignaud , Alain Portal , Denis Barbier , Nicolas Francois , Florentin Duneau , Thomas Blein et David Prevot Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.9.1 16 juin 2024 pthread_cond_init(3)