fr - en to fr translation catalogue (138 entries)

en: NAME
fr: NOM

en: pthread_atfork - register handlers to be called at fork(2) time
fr: pthread_atfork - Enregistrer des gestionnaires à invoquer lors de l'appel à fork(2)

en: !pthread_atfork! registers handler functions to be called just before and just after a new process is created with !fork!(2). The |prepare| handler will be called from the parent process, just before the new process is created. The |parent| handler will be called from the parent process, just before !fork!(2) returns. The |child| handler will be called from the child process, just before !fork!(2) returns.
fr: B<pthread_atfork>() enregistre les fonctions à appeler juste avant et juste après la création d'un nouveau processus par B<fork>(2). Le gestionnaire I<prepare> est appelé par le processus parent juste avant la création du nouveau processus. Le gestionnaire I<parent> est appelé par le processus parent juste avant que B<fork>(2) finisse. Le gestionnaire I<child> est appelé par le processus fils juste avant la fin de l'appel B<fork>(2).

en: One or several of the three handlers |prepare|, |parent| and |child| can be given as !NULL!, meaning that no handler needs to be called at the corresponding point.
fr: L'un ou plusieurs des trois gestionnaires I<prepare>, I<parent> et I<child> peut être affecté à B<NULL>, ce qui signifie qu'aucun gestionnaire ne sera appelé au moment correspondant.

en: !pthread_atfork! can be called several times to install several sets of handlers. At !fork!(2) time, the |prepare| handlers are called in LIFO order (last added with !pthread_atfork!, first called before !fork!), while the |parent| and |child| handlers are called in FIFO order (first added, first called).
fr: B<pthread_atfork> peut être appelée plusieurs fois pour enregistrer plusieurs ensembles de gestionnaires. Lors de l'appel à B<fork>(2), les gestionnaires I<prepare> sont appelés dans l'ordre LIFO (dernier ajouté avec B<pthread_affork>, premier appelé avant B<fork>(2)), alors que les gestionnaires I<parent> et I<child> sont appelés dans l'ordre FIFO (premier ajouté, premier appelé).

en: To understand the purpose of !pthread_atfork!, recall that !fork!(2)  duplicates the whole memory space, including mutexes in their current locking state, but only the calling thread: other threads are not running in the child process.  The mutexes are not usable after the !fork! and must be initialized with |pthread_mutex_init| in the child process.  This is a limitation of the current implementation and might or might not be present in future versions.
fr: Pour comprendre l'objectif de B<pthread_atfork>(), rappelons que B<fork>(2) copie toute l'image mémoire du processus, y compris ses mutexes dans leur état de bloquage courant, mais seulement le thread appelant\ : les autres threads ne s'exécutent pas dans le processus fils. Les mutexes ne sont pas utilisables après le B<fork>() et doivent être initialisés avec B<pthread_mutex_init>() dans le processus fils. C'est une limitation de l'implémentation actuelle et peut être ou ne pas être présente dans les prochaines versions.

en: RETURN VALUE
fr: VALEUR RENVOYÉE

en: !pthread_atfork! returns 0 on success and a non-zero error code on error.
fr: B<pthread_atfork>() retourne 0 en cas de succès et un code d'erreur non nul en cas d'erreur.

en: ERRORS
fr: ERREURS

en: !ENOMEM!
fr: B<ENOMEM>

en: insufficient memory available to register the handlers.
fr: Pas assez de mémoire disponible pour enregistrer les gestionnaires.

en: AUTHOR
fr: AUTEUR

en: Xavier Leroy E<lt>Xavier.Leroy@inria.frE<gt>
fr: Xavier Leroy E<lt>Xavier DOT Leroy AT inria DOT frE<gt>

en: SEE ALSO
fr: VOIR AUSSI

en: !fork!(2), !pthread_mutex_lock!(3), !pthread_mutex_unlock!(3).
fr: B<fork>(2), B<pthread_mutex_lock>(3), B<pthread_mutex_unlock>(3).

en: pthread_attr_init, pthread_attr_destroy, pthread_attr_setdetachstate, pthread_attr_getdetachstate, pthread_attr_setschedparam, pthread_attr_getschedparam, pthread_attr_setschedpolicy, pthread_attr_getschedpolicy, pthread_attr_setinheritsched, pthread_attr_getinheritsched, pthread_attr_setscope, pthread_attr_getscope - thread creation attributes
fr: pthread_attr_init, pthread_attr_destroy, pthread_attr_setdetachstate, pthread_attr_getdetachstate, pthread_attr_setschedparam, pthread_attr_getschedparam, pthread_attr_setschedpolicy, pthread_attr_getschedpolicy, pthread_attr_setinheritsched, pthread_attr_getinheritsched, pthread_attr_setscope, pthread_attr_getscope - Attributs de création de thread

en: Setting attributes for threads is achieved by filling a thread attribute object |attr| of type !pthread_attr_t!, then passing it as second argument to !pthread_create!(3). Passing !NULL! is equivalent to passing a thread attribute object with all attributes set to their default values.
fr: Pour modifier les attributs des threads, il faut remplir la structure des attributs de threads I<attr>, qui est du type B<pthread_attr_t>, puis la passer en tant que second argument à B<pthread_create>(3). Si l'argument est égal à B<NULL>, cela revient à choisir les paramètres par défaut pour tous les attributs.

en: !pthread_attr_init! initializes the thread attribute object |attr| and fills it with default values for the attributes. (The default values are listed below for each attribute.)
fr: B<pthread_attr_init>() initialise la structure d'attributs de thread I<attr> et la remplit avec les valeurs par défaut pour tous les attributs (Les valeurs par défauts de chaque attribut sont données plus bas).

en: Each attribute |attrname| (see below for a list of all attributes) can be individually set using the function !pthread_attr_set!|attrname| and retrieved using the function !pthread_attr_get!|attrname|.
fr: Chaque attribut I<attrname> (la liste de tous les attributs se trouve plus bas) peut être individuellement modifié en utilisant la fonction B<pthread_attr_set(>I<attrname)> et récupéré à l'aide de la fonction B<pthread_attr_get(>I<attrname).>

en: !pthread_attr_destroy! destroys a thread attribute object, which must not be reused until it is reinitialized. !pthread_attr_destroy! does nothing in the LinuxThreads implementation.
fr: B<pthread_attr_destroy>() détruit une structure d'attribut de thread, qui ne doit plus jamais être réutilisée jusqu'à ce qu'elle soit réinitialisée. B<pthread_attr_destroy>() ne fait rien dans l'implémentation LinuxThreads.

en: Attribute objects are consulted only when creating a new thread. The same attribute object can be used for creating several threads. Modifying an attribute object after a call to !pthread_create! does not change the attributes of the thread previously created.
fr: Les structures d'attributs ne sont consultées que lors de la création d'un nouveau thread. La même structure d'attributs peut être réutilisée pour créer plusieurs threads. Modifier une structure d'attributs après un appel à B<pthread_create>() ne modifie pas les attributs du thread précédemment créé.

en: The following thread attributes are supported:
fr: Les attributs de thread disponibles sont les suivants\ :

en: Control whether the thread is created in the joinable state (value !PTHREAD_CREATE_JOINABLE!) or in the detached state (!PTHREAD_CREATE_DETACHED!).
fr: Indique si le thread est créé dans l'état joignable (valeur B<PTHREAD_CREATE_JOINABLE>) ou dans l'état détaché (B<PTHREAD_CREATE_DETACHED>).

en: Default value: !PTHREAD_CREATE_JOINABLE!.
fr: Valeur par défaut\ : B<PTHREAD_CREATE_JOINABLE>.

en: In the joinable state, another thread can synchronize on the thread termination and recover its termination code using !pthread_join!(3), but some of the thread resources are kept allocated after the thread terminates, and reclaimed only when another thread performs !pthread_join!(3) on that thread.
fr: Dans l'état joignable, un autre thread peut se synchroniser sur la fin du thread et récupérer son code de terminaison en utilisant B<pthread_join>(3), mais certaines ressources du thread resteront allouées après sa fin et ne seront libérées que lorsqu'un autre thread appellera B<pthread_join>(3) sur ce thread.

en: In the detached state, the thread resources are immediately freed when it terminates, but !pthread_join!(3) cannot be used to synchronize on the thread termination.
fr: Dans l'état détaché, les ressources du thread sont immédiatement libérées quand il se termine, mais B<pthread_join>(3) ne peut être utilisé pour se synchroniser sur la fin du thread.

en: A thread created in the joinable state can later be put in the detached thread using !pthread_detach!(3).
fr: Un thread créé dans l'état joignable peut ensuite être mis dans l'état détaché avec B<pthread_detach>(3).

en: Select the scheduling policy for the thread: one of !SCHED_OTHER! (regular, non-realtime scheduling), !SCHED_RR! (realtime, round-robin) or !SCHED_FIFO! (realtime, first-in first-out). See !sched_setpolicy!(2) for more information on scheduling policies.
fr: Change la politique d'ordonnancement du thread pour l'une parmi B<SCHED_OTHER> (processus normal, non temps réel), B<SCHED_RR> (temps réel, «\ round-robin\ ») ou B<SCHED_FIFO> (temps réel, «\ fifo\ »). Voyez B<sched_setpolicy>(2) pour plus d'informations sur les politiques d'ordonnancement.

en: Default value: !SCHED_OTHER!.
fr: Valeur par défaut\ : B<SCHED_OTHER>.

en: The realtime scheduling policies !SCHED_RR! and !SCHED_FIFO! are available only to processes with superuser privileges.
fr: Les politiques d'ordonnancement temps réel B<SCHED_RR> et B<SCHED_FIFO> ne sont disponibles que pour les processus possédant les privilèges du superutilisateur.

en: The scheduling policy of a thread can be changed after creation with !pthread_setschedparam!(3).
fr: La politique d'ordonnancement d'un thread peut être modifiée après sa création avec B<pthread_setschedparam>(3).

en: Contain the scheduling parameters (essentially, the scheduling priority) for the thread. See !sched_setparam!(2) for more information on scheduling parameters.
fr: Contient les paramètres d'ordonnancement (essentiellement, la priorité d'ordonnancement) du thread. Voyez B<sched_setparam>(2) pour plus d'informations sur les paramètres d'ordonnancement.

en: Default value: priority is 0.
fr: Valeur par défaut\ : priorité à 0.

en: This attribute is not significant if the scheduling policy is !SCHED_OTHER!; it only matters for the realtime policies !SCHED_RR! and !SCHED_FIFO!.
fr: Cet attribut est sans signification si la politique d'ordonnancement est B<SCHED_OTHER>\ ; il n'a d'importance que pour les ordonnancements temps réel B<SCHED_RR> et B<SCHED_FIFO>.

en: The scheduling priority of a thread can be changed after creation with !pthread_setschedparam!(3).
fr: La priorité d'ordonnancement d'un thread peut être modifiée après sa création avec B<pthread_setschedparam>(3).

en: Indicate whether the scheduling policy and scheduling parameters for the newly created thread are determined by the values of the |schedpolicy| and |schedparam| attributes (value !PTHREAD_EXPLICIT_SCHED!) or are inherited from the parent thread (value !PTHREAD_INHERIT_SCHED!).
fr: Indique si la politique et les paramètres d'ordonnancement du nouveau thread sont déterminés par les valeurs des attributs I<schedpolicy> et I<schedparam> (valeur B<PTHREAD_EXPLICIT_SCHED>) ou sont héritées du thread parent (valeur B<PTHREAD_INHERIT_SCHED>).

en: Default value: !PTHREAD_EXPLICIT_SCHED!.
fr: Valeur par défaut\ : B<PTHREAD_EXPLICIT_SCHED>.

en: Define the scheduling contention scope for the created thread.  The only value supported in the LinuxThreads implementation is !PTHREAD_SCOPE_SYSTEM!, meaning that the threads contend for CPU time with all processes running on the machine. In particular, thread priorities are interpreted relative to the priorities of all other processes on the machine. The other value specified by the standard, !PTHREAD_SCOPE_PROCESS!, means that scheduling contention occurs only between the threads of the running process: thread priorities are interpreted relative to the priorities of the other threads of the process, regardless of the priorities of other processes.  !PTHREAD_SCOPE_PROCESS! is not supported in LinuxThreads.
fr: Définit comment sont interprétés les paramètres d'ordonnancement du nouveau thread. Une seule valeur est supportée dans l'implémentation LinuxThreads\ : B<PTHREAD_SCOPE_SYSTEM>, qui signifie que tous les threads sont en compétition avec tous les processus en cours d'exécution pour le temps processeur. En particulier, les priorités des threads sont interprétées relativement aux priorités de tous les autres processus de la machine. L'autre valeur spécifiée par le standard, B<PTHREAD_SCOPE_PROCESS>, signifie que les threads ne sont en compétition qu'avec les autres threads du même processus\ : les priorités des threads sont interprétées relativement à celles des autres threads du processus, quelle que soit la priorité des autres processus. B<PTHREAD_SCOPE_PROCESS> n'est pas supportée dans LinuxThreads.

en: Default value: !PTHREAD_SCOPE_SYSTEM!.
fr: Valeur par défaut\ : B<PTHREAD_SCOPE_SYSTEM>.

en: All functions return 0 on success and a non-zero error code on error.  On success, the !pthread_attr_get!|attrname| functions also store the current value of the attribute |attrname| in the location pointed to by their second argument.
fr: Toutes ces fonctions renvoient 0 en cas de succès et un code d'erreur non nul en cas d'erreur. En cas de succès, les fonctions B<pthread_attr_get>(I<attrname>) sauvegardent également la valeur courante de l'attribut I<attrname> à l'emplacement pointé par leur second argument.

en: The !pthread_attr_setdetachstate! function returns the following error codes on error:
fr: La fonction B<pthread_attr_setdetachstate>() renvoie le code d'erreur suivant lors d'une erreur\ :

en: !EINVAL!
fr: B<EINVAL>

en: the specified |detachstate| is not one of !PTHREAD_CREATE_JOINABLE! or !PTHREAD_CREATE_DETACHED!.
fr: Le paramètre I<detachstate> spécifié n'est ni B<PTHREAD_CREATE_JOINABLE> ni B<PTHREAD_CREATE_DETACHED>.

en: The !pthread_attr_setschedparam! function returns the following error codes on error:
fr: La fonction B<pthread_attr_setschedparam>() renvoie le code d'erreur suivant lors d'une erreur\ :

en: the priority specified in |param| is outside the range of allowed priorities for the scheduling policy currently in |attr| (1 to 99 for !SCHED_FIFO! and !SCHED_RR!; 0 for !SCHED_OTHER!).
fr: La priorité indiquée par I<param> n'est pas dans l'intervalle autorisé par la politique d'ordonnancement actuellement dans I<attr> (1 à 99 pour B<SCHED_FIFO> et B<SCHED_RR>\ ; 0 pour B<SCHED_OTHER>).

en: The !pthread_attr_setschedpolicy! function returns the following error codes on error:
fr: La fonction B<pthread_attr_setschedpolicy>() renvoie l'un des codes d'erreur lors d'une erreur\ :

en: the specified |policy| is not one of !SCHED_OTHER!, !SCHED_FIFO!, or !SCHED_RR!.
fr: Le paramètre I<policy> spécifié n'est ni B<SCHED_OTHER>, ni B<SCHED_FIFO>, ni B<SCHED_RR>.

en: !ENOTSUP!
fr: B<ENOTSUP>

en: |policy| is !SCHED_FIFO! or !SCHED_RR!, and the effective user of the calling process is not super-user.
fr: I<policy> est B<SCHED_FIFO> ou B<SCHED_RR>, et l'utilisateur effectif du processus appelant n'est pas le superutilisateur.

en: The !pthread_attr_setinheritsched! function returns the following error codes on error:
fr: La fonction B<pthread_attr_setinheritsched>() renvoie le code d'erreur lors d'un erreur\ :

en: the specified |inherit| is not one of !PTHREAD_INHERIT_SCHED! or !PTHREAD_EXPLICIT_SCHED!.
fr: Le paramètre I<inherit> spécifié n'est ni B<PTHREAD_INHERIT_SCHED> ni B<PTHREAD_EXPLICIT_SCHED>.

en: The !pthread_attr_setscope! function returns the following error codes on error:
fr: La fonction B<pthread_attr_setscope>() renvoie l'un des codes d'erreur lors d'une erreur\ :

en: the specified |scope| is not one of !PTHREAD_SCOPE_SYSTEM! or !PTHREAD_SCOPE_PROCESS!.
fr: Le paramètre I<scope> spécifié n'est ni B<PTHREAD_SCOPE_SYSTEM> ni B<PTHREAD_SCOPE_PROCESS>.

en: the specified |scope| is !PTHREAD_SCOPE_PROCESS! (not supported).
fr: Le paramètre I<scope> spécifié est B<PTHREAD_SCOPE_PROCESS> (non géré).

en: !pthread_create!(3), !pthread_join!(3), !pthread_detach!(3), !pthread_setschedparam!(3).
fr: B<pthread_create>(3), B<pthread_join>(3), B<pthread_detach>(3), B<pthread_setschedparam>(3).

en: pthread_cancel, pthread_setcancelstate, pthread_setcanceltype, pthread_testcancel - thread cancellation
fr: pthread_cancel, pthread_setcancelstate, pthread_setcanceltype, pthread_testcancel - Annulation de thread

en: Cancellation is the mechanism by which a thread can terminate the execution of another thread. More precisely, a thread can send a cancellation request to another thread. Depending on its settings, the target thread can then either ignore the request, honor it immediately, or defer it till it reaches a cancellation point.
fr: L'annulation est le mécanisme par lequel un thread peut interrompre l'exécution d'un autre thread. C'est l'équivalent pour les threads de la fonction B<kill>() des processus classiques. Plus précisément, un thread peut envoyer une requête d'annulation à un autre thread. Selon sa configuration, le thread visé peut soit ignorer la requête, soit l'honorer immédiatement, soit enfin retarder son application jusqu'à ce qu'un point d'annulation soit atteint.

en: When a thread eventually honors a cancellation request, it performs as if !pthread_exit(PTHREAD_CANCELED)! has been called at that point: all cleanup handlers are executed in reverse order, finalization functions for thread-specific data are called, and finally the thread stops executing with the return value !PTHREAD_CANCELED!. See !pthread_exit!(3) for more information.
fr: Quand un thread réalise finalement la requête d'annulation, il se comporte comme si la fonction B<pthread_exit(PTHREAD_CANCELED)> avait été appelée à cet endroit\ : tous les gestionnaires de nettoyage sont exécutés dans l'ordre inverse de leur enregistrement. Puis les fonctions de destruction des données spécifiques au thread sont appelées. Enfin, le thread interrompt définitivement son exécution en retournant la valeur B<PTHREAD_CANCELED>. Voyez B<pthread_exit>(3) pour plus d'informations.

en: !pthread_cancel! sends a cancellation request to the thread denoted by the |thread| argument.
fr: B<pthread_cancel>() envoie une requête d'annulation au thread indiqué par le paramètre I<thread>.

en: !pthread_setcancelstate! changes the cancellation state for the calling thread -- that is, whether cancellation requests are ignored or not. The |state| argument is the new cancellation state: either !PTHREAD_CANCEL_ENABLE! to enable cancellation, or !PTHREAD_CANCEL_DISABLE! to disable cancellation (cancellation requests are ignored). If |oldstate| is not !NULL!, the previous cancellation state is stored in the location pointed to by |oldstate|, and can thus be restored later by another call to !pthread_setcancelstate!.
fr: B<pthread_setcancelstate>() modifie l'état d'annulation du thread appelant, c'est-à-dire si les requêtes d'annulation sont ignorées ou non. Le paramètre I<state> est le nouvel état d'annulation\ : soit B<PTHREAD_CANCEL_ENABLE> pour autoriser les annulations, soit B<PTHREAD_CANCEL_DISABLE> pour les désactiver (les requêtes d'annulation sont alors ignorées). Si I<oldstate> est différent de B<NULL>, le précédent état d'annulation est sauvegardé à l'emplacement pointé par I<oldstate>, et peut donc être restauré plus tard par un autre appel à B<pthread_setcancelstate>.

en: !pthread_setcanceltype! changes the type of responses to cancellation requests for the calling thread: asynchronous (immediate) or deferred.  The |type| argument is the new cancellation type: either !PTHREAD_CANCEL_ASYNCHRONOUS! to cancel the calling thread as soon as the cancellation request is received, or !PTHREAD_CANCEL_DEFERRED! to keep the cancellation request pending until the next cancellation point. If |oldtype| is not !NULL!, the previous cancellation state is stored in the location pointed to by |oldtype|, and can thus be restored later by another call to !pthread_setcanceltype!.
fr: B<pthread_setcanceltype>() modifie le mode de réponse de la requête d'annulation du thread appelant\ : asynchrone (immédiate) ou retardée. Le paramètre I<type> est le nouveau mode d'annulation\ : soit B<PTHREAD_CANCEL_ASYNCHRONOUS> pour annuler le thread appelant dès que possible après la réception d'une requête d'annulation, soit B<PTHREAD_CANCEL_DEFERRED> pour mettre en attente la requête jusqu'à ce qu'un point d'annulation soit atteint. Si I<oldtype> n'est pas égal à B<NULL>, alors le précédent état d'annulation est sauvegardé à l'emplacement pointé par I<oldtype>, et peut donc être restauré plus tard par un autre appel à B<pthread_setcanceltype>().

en: Threads are always created by !pthread_create!(3) with cancellation enabled and deferred. That is, the initial cancellation state is !PTHREAD_CANCEL_ENABLE! and the initial type is !PTHREAD_CANCEL_DEFERRED!.
fr: Les threads sont toujours créés par B<pthread_create>(3) avec annulation activée et retardée. C'est-à-dire que l'état initial d'annulation est B<PTHREAD_CANCEL_ENABLE> et que le mode initial est B<PTHREAD_CANCEL_DEFERRED>.

en: Cancellation points are those points in the program execution where a test for pending cancellation requests is performed and cancellation is executed if positive. The following POSIX threads functions are cancellation points:
fr: Les points d'annulation sont des points dans l'exécution d'un programme où l'on teste si des requêtes d'annulation ne sont pas en attente de traitement. Si des requêtes sont en attente, alors l'annulation du thread est exécutée. Les fonctions suivantes relatives aux threads de la norme POSIX sont des points d'annulation implicites\ :

en: !pthread_join!(3)
fr: B<pthread_join>(3)

en: !pthread_cond_wait!(3)
fr: B<pthread_cond_wait>(3)

en: !pthread_cond_timedwait!(3)
fr: B<pthread_cond_timedwait>(3)

en: !pthread_testcancel!(3)
fr: B<pthread_testcancel>(3)

en: !sem_wait!(3)
fr: B<sem_wait>(3)

en: !sigwait!(3)
fr: B<sigwait>(3)

en: All other POSIX threads functions are guaranteed not to be cancellation points. That is, they never perform cancellation in deferred cancellation mode.
fr: Toutes les autres fonctions POSIX relatives aux threads sont garanties ne pas être des points d'annulation. C'est-à-dire qu'elles ne traitent pas les requêtes d'annulation en attente de traitement.

en: !pthread_testcancel! does nothing except testing for pending cancellation and executing it. Its purpose is to introduce explicit checks for cancellation in long sequences of code that do not call cancellation point functions otherwise.
fr: B<pthread_testcancel>() ne fait rien, si ce n'est tester si une requête d'annulation est en attente de réalisation et la traiter. Sa fonction est d'introduire des tests explicites pour vérifier ponctuellement qu'aucune requête d'annulation n'a été reçue lors des longues séquences de code sans points d'annulation.

en: !pthread_cancel!, !pthread_setcancelstate! and !pthread_setcanceltype! return 0 on success and a non-zero error code on error.
fr: B<pthread_cancel>(), B<pthread_setcancelstate>() et B<pthread_setcanceltype>() renvoient 0 en cas de succès et un code d'erreur non nul en cas d'erreur.

en: !pthread_cancel! returns the following error code on error:
fr: B<pthread_cancel>() renvoie le code d'erreur suivant\ :

en: !ESRCH!
fr: B<ESRCH>

en: no thread could be found corresponding to that specified by the |thread| ID.
fr: Aucun thread correspondant au descripteur I<thread> n'a pu êtres trouvé.

en: !pthread_setcancelstate! returns the following error code on error:
fr: B<pthread_setcancelstate>() renvoie le code d'erreur suivant\ :

en: the |state| argument is not !PTHREAD_CANCEL_ENABLE! nor !PTHREAD_CANCEL_DISABLE!
fr: Le paramètre I<state> n'est ni B<PTHREAD_CANCEL_ENABLE> ni B<PTHREAD_CANCEL_DISABLE>.

en: !pthread_setcanceltype! returns the following error code on error:
fr: B<pthread_setcanceltype>() renvoie le code d'erreur suivant\ :

en: the |type| argument is not !PTHREAD_CANCEL_DEFERRED! nor !PTHREAD_CANCEL_ASYNCHRONOUS!
fr: Le paramètre I<type> n'est ni B<PTHREAD_CANCEL_DEFERRED> ni B<PTHREAD_CANCEL_ASYNCHRONOUS>.

en: !pthread_exit!(3), !pthread_cleanup_push!(3), !pthread_cleanup_pop!(3).
fr: B<pthread_exit>(3), B<pthread_cleanup_push>(3), B<pthread_cleanup_pop>(3)

en: BUGS
fr: BOGUES

en: POSIX specifies that a number of system calls (basically, all system calls that may block, such as !read!(2), !write!(2), !wait!(2), etc.) and library functions that may call these system calls (e.g.  !fprintf!(3)) are cancellation points.  LinuxThreads is not yet integrated enough with the C library to implement this, and thus none of the C library functions is a cancellation point.
fr: POSIX spécifie qu'un certain nombre d'appels système (fondamentalement, tous les appels système bloquant comme B<read>(2), B<write>(2), B<wait>(2), etc.) et les fonctions des bibliothèques qui invoquent ces appels système (par exemple, B<fprintf>(3)) sont des points d'annulation. LinuxThreads n'est pas encore assez intégré à la bibliothèque standard C pour implémenter cela\ ; et donc, aucune fonction de la glibc n'est un point d'annulation.

en: For system calls at least, there is a workaround. Cancellation requests are transmitted to the target thread by sending it a signal. That signal will interrupt all blocking system calls, causing them to return immediately with the !EINTR! error. So, checking for cancellation during a !read! system call, for instance, can be achieved as follows:
fr: Pour les appels système, il existe un moyen détourné d'y parvenir. Les requêtes d'annulation sont transmises au thread ciblé en lui envoyant un signal. Ce dernier va interrompre tous les appels système bloquant, ils renvoient alors immédiatement l'erreur B<EINTR>. Ainsi, pour vérifier qu'un thread n'a pas été annulé au cours de l'appel système B<read>(), par exemple, on peut utiliser la méthode suivante\ :

en: pthread_cleanup_push, pthread_cleanup_pop, pthread_cleanup_push_defer_np, pthread_cleanup_pop_restore_np - install and remove cleanup handlers
fr: pthread_cleanup_push, pthread_cleanup_pop, pthread_cleanup_push_defer_np, pthread_cleanup_pop_restore_np - Installer et enlever des gestionnaires de nettoyage

en: Cleanup handlers are functions that get called when a thread terminates, either by calling !pthread_exit!(3) or because of cancellation. Cleanup handlers are installed and removed following a stack-like discipline.
fr: Les gestionnaires de nettoyage sont des fonctions qui sont appelées lorsqu'un thread se termine, soit en appelant B<pthread_exit>(3) soit parce qu'il a été annulé. Les gestionnaires de nettoyage sont installés et enlevés à la manière d'une pile.

en: The purpose of cleanup handlers is to free the resources that a thread may hold at the time it terminates. In particular, if a thread exits or is cancelled while it owns a locked mutex, the mutex will remain locked forever and prevent other threads from executing normally. The best way to avoid this is, just before locking the mutex, to install a cleanup handler whose effect is to unlock the mutex. Cleanup handlers can be used similarly to free blocks allocated with !malloc!(3) or close file descriptors on thread termination.
fr: Le rôle d'un gestionnaire de nettoyage est de libérer les ressources acquises par un thread lorsque son exécution s'achève. En particulier, si un thread se termine, ou est annulé alors qu'il verrouille un mutex, ce dernier restera verrouillé pour toujours, empêchant d'autres threads de s'exécuter normalement. La meilleure manière d'empêcher cela est d'installer un gestionnaire de nettoyage dont la fonction sera de déverrouiller le mutex. Les gestionnaires de nettoyage peuvent également être utilisés pour libérer des blocs de mémoire alloués par B<malloc>(3), ou fermer des descripteurs de fichiers lorsque le thread se termine.

en: !pthread_cleanup_push! installs the |routine| function with argument |arg| as a cleanup handler. From this point on to the matching !pthread_cleanup_pop!, the function |routine| will be called with arguments |arg| when the thread terminates, either through !pthread_exit!(3)  or by cancellation. If several cleanup handlers are active at that point, they are called in LIFO order: the most recently installed handler is called first.
fr: B<pthread_cleanup_push>() installe la fonction I<routine> avec le paramètre I<arg> en tant que gestionnaire de nettoyage. À partir de ce point jusqu'à un appel à la fonction B<pthread_cleanup_pop>(), la fonction I<routine> sera appelée avec le paramètre I<arg> quand le thread se terminera, soit par B<pthread_exit>(3), soit à la suite d'une annulation. Si plusieurs gestionnaires de nettoyage ont été enregistrés, ils seront exécutés dans l'ordre LIFO (dernier entré, premier sorti).

en: !pthread_cleanup_pop! removes the most recently installed cleanup handler. If the |execute| argument is not 0, it also executes the handler, by calling the |routine| function with arguments |arg|. If the |execute| argument is 0, the handler is only removed but not executed.
fr: B<pthread_cleanup_pop>() désactive le dernier gestionnaire de nettoyage installé. Si le paramètre I<execute> ne vaut pas 0, ce gestionnaire est exécuté en appelant la fonction I<routine> avec les paramètres I<arg>. Si le paramètre I<execute> vaut 0, le gestionnaire est seulement désactivé mais pas exécuté.

en: Matching pairs of !pthread_cleanup_push! and !pthread_cleanup_pop! must occur in the same function, at the same level of block nesting.  Actually, !pthread_cleanup_push! and !pthread_cleanup_pop! are macros, and the expansion of !pthread_cleanup_push! introduces an open brace !{! with the matching closing brace !}! being introduced by the expansion of the matching !pthread_cleanup_pop!.
fr: Les paires de fonctions B<pthread_cleanup_push>() et B<pthread_cleanup_pop>() doivent être exécutées dans le même bloc lexical, au même niveau et ne peuvent pas être entrelacées avec une autre paire. En fait, B<pthread_cleanup_push>() et B<pthread_cleanup_pop>() sont des macros, et l'expansion de B<pthread_cleanup_push>() introduit une accolade ouvrante «\ B<{>\ » fermée par l'accolade «\ B<}>\ » introduite par l'expansion de la macro correspondante, B<pthread_cleanup_pop>().

en: !pthread_cleanup_push_defer_np! is a non-portable extension that combines !pthread_cleanup_push! and !pthread_setcanceltype!(3).  It pushes a cleanup handler just as !pthread_cleanup_push! does, but also saves the current cancellation type and sets it to deferred cancellation. This ensures that the cleanup mechanism is effective even if the thread was initially in asynchronous cancellation mode.
fr: B<pthread_cleanup_push_defer_np>() est une extension non portable qui combine B<pthread_cleanup_push>() et B<pthread_setcanceltype>(3). Elle enregistre le gestionnaires de nettoyage comme le fait B<pthread_cleanup_push>(), mais sauvegarde également le mode d'annulation courant et le passe en mode d'annulation retardée. Cela permet de s'assurer que le mécanisme de nettoyage est efficace même si le thread fonctionne en mode d'annulation asynchrone.

en: !pthread_cleanup_pop_restore_np! pops a cleanup handler introduced by !pthread_cleanup_push_defer_np!, and restores the cancellation type to its value at the time !pthread_cleanup_push_defer_np! was called.
fr: B<pthread_cleanup_pop_restore_np>() dépile le dernier gestionnaire de nettoyage enregistré par B<pthread_cleanup_push_defer_np>(), et restaure le mode d'annulation à sa valeur lorsque B<pthread_cleanup_push_defer_np>() a été appelée.

en: !pthread_cleanup_push_defer_np! and !pthread_cleanup_pop_restore_np! must occur in matching pairs, at the same level of block nesting.
fr: B<pthread_cleanup_push_defer_np>() et B<pthread_cleanup_pop_restore_np>() doivent être exécutées en paire, dans le même bloc, au même niveau et ne peuvent pas être entrelacées avec une autre paire.

en: The following sequence
fr: La séquence suivante

en: is functionally equivalent to (but more compact and more efficient than)
fr: est fonctionnellement équivalente (mais plus compacte et plus efficace) à

en: None.
fr: Aucune.

en: !pthread_exit!(3), !pthread_cancel!(3), !pthread_setcanceltype!(3).
fr: B<pthread_exit>(3), B<pthread_cancel>(3), B<pthread_setcanceltype>(3)

en: EXAMPLE
fr: EXEMPLE

en: Here is how to lock a mutex |mut| in such a way that it will be unlocked if the thread is canceled while |mut| is locked:
fr: Voici comment verrouiller un mutex I<mut>, de telle manière qu'il sera déverrouillé si le thread est annulé, alors que I<mut> est verrouillé\ :

en: B<pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* do some work */
    pthread_mutex_unlock(&mut);
    pthread_cleanup_pop(0);>
fr: B<pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* Faire des choses */
    pthread_mutex_unlock(&mut);
    pthread_cleanup_pop(0);>

en: Equivalently, the last two lines can be replaced by
fr: Les deux dernières lignes peuvent être remplacées par\ :

en: Notice that the code above is safe only in deferred cancellation mode (see !pthread_setcanceltype!(3)). In asynchronous cancellation mode, a cancellation can occur between !pthread_cleanup_push! and !pthread_mutex_lock!, or between !pthread_mutex_unlock! and !pthread_cleanup_pop!, resulting in both cases in the thread trying to unlock a mutex not locked by the current thread. This is the main reason why asynchronous cancellation is difficult to use.
fr: Remarquez que le code ci-dessus n'est fiable qu'en mode d'annulation retardée (voyez B<pthread_setcanceltype>(3)). En mode d'annulation asynchrone, une annulation peut intervenir entre B<pthread_cleanup_push>() et B<pthread_mutex_lock>(), ou entre B<pthread_mutex_unlock>() et B<pthread_cleanup_pop>(), résultant dans les deux cas en un thread tentant de déverrouiller un mutex non verrouillé par le thread courant. C'est la principale raison pour laquelle le mode d'annulation asynchrone est si problématique à utiliser.

en: If the code above must also work in asynchronous cancellation mode, then it must switch to deferred mode for locking and unlocking the mutex:
fr: Afin que ce code fonctionne aussi en mode d'annulation asynchrone, il doit passer en mode d'annulation retardée pour verrouiller et déverrouiller le mutex\ :

en: B<pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
    pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* do some work */
    pthread_cleanup_pop(1);
    pthread_setcanceltype(oldtype, NULL);>
fr: B<pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, &oldtype);
    pthread_cleanup_push(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* Faire des choses */
    pthread_cleanup_pop(1);
    pthread_setcanceltype(oldtype, NULL);>

en: The code above can be rewritten in a more compact and more efficient way, using the non-portable functions !pthread_cleanup_push_defer_np! and !pthread_cleanup_pop_restore_np!:
fr: Le code ci-dessus peut être ré-écrit de manière plus compacte et plus efficace en utilisant les extensions non portables B<pthread_cleanup_push_defer_np>() et B<pthread_cleanup_pop_restore_np>()\ :

en: B<pthread_cleanup_push_restore_np(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* do some work */
    pthread_cleanup_pop_restore_np(1);>
fr: B<pthread_cleanup_push_restore_np(pthread_mutex_unlock, (void *) &mut);
    pthread_mutex_lock(&mut);
    /* faire des choses */
    pthread_cleanup_pop_restore_np(1);>

en: pthread_cond_init, pthread_cond_destroy, pthread_cond_signal, pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait - operations on conditions
fr: pthread_cond_init, pthread_cond_destroy, pthread_cond_signal, pthread_cond_broadcast, pthread_cond_wait, pthread_cond_timedwait - Opérations sur les conditions

en: A condition (short for ``condition variable'') is a synchronization device that allows threads to suspend execution and relinquish the processors until some predicate on shared data is satisfied. The basic operations on conditions are: signal the condition (when the predicate becomes true), and wait for the condition, suspending the thread execution until another thread signals the condition.
fr: Une condition (abréviation pour «\ variable condition\ ») est un mécanisme de synchronisation permettant à un thread de suspendre son exécution jusqu'à ce qu'une certaine condition (un prédicat) sur des données partagées soit vérifiée. Les opérations fondamentales sur les conditions sont\ : signaler la condition (quand le prédicat devient vrai), et attendre la condition en suspendant l'exécution du thread jusqu'à ce qu'un autre thread signale la condition.

en: A condition variable must always be associated with a mutex, to avoid the race condition where a thread prepares to wait on a condition variable and another thread signals the condition just before the first thread actually waits on it.
fr: Une variable condition doit toujours être associée à un mutex, pour éviter une condition concurrente où un thread se prépare à attendre une condition et un autre thread signale la condition juste avant que le premier n'attende réellement.

en: !pthread_cond_init! initializes the condition variable |cond|, using the condition attributes specified in |cond_attr|, or default attributes if |cond_attr| is !NULL!. The LinuxThreads implementation supports no attributes for conditions, hence the |cond_attr| parameter is actually ignored.
fr: B<pthread_cond_init>() initialise la variable condition I<cond>, en utilisant les attributs de condition spécifiés par I<cond_attr>, ou les attributs par défaut si I<cond_attr> vaut B<NULL>. L'implémentation LinuxThreads ne supporte aucun attribut de condition, aussi le paramètre I<cond_attr> est pour l'instant ignoré.

en: Variables of type !pthread_cond_t! can also be initialized statically, using the constant !PTHREAD_COND_INITIALIZER!.
fr: Les variables de type B<pthread_cond_t> peuvent également être statiquement initialisées, en utilisant la constante B<PTHREAD_COND_INITIALIZER>.

en: !pthread_cond_signal! restarts one of the threads that are waiting on the condition variable |cond|. If no threads are waiting on |cond|, nothing happens. If several threads are waiting on |cond|, exactly one is restarted, but it is not specified which.
fr: B<pthread_cond_signal>() relance l'un des threads attendant la variable condition I<cond>. S'il n'existe aucun thread répondant à ce critère, rien ne se produit. Si plusieurs threads attendent sur I<cond>, seul l'un d'entre eux sera relancé, mais il est impossible de savoir lequel.

en: !pthread_cond_broadcast! restarts all the threads that are waiting on the condition variable |cond|. Nothing happens if no threads are waiting on |cond|.
fr: B<pthread_cond_broadcast>() relance tous les threads attendant sur la variable condition I<cond>. Rien ne se passe s'il n'y a aucun thread attendant sur I<cond>.

en: !pthread_cond_wait! atomically unlocks the |mutex| (as per !pthread_unlock_mutex!) and waits for the condition variable |cond| to be signaled. The thread execution is suspended and does not consume any CPU time until the condition variable is signaled. The |mutex| must be locked by the calling thread on entrance to !pthread_cond_wait!. Before returning to the calling thread, !pthread_cond_wait! re-acquires |mutex| (as per !pthread_lock_mutex!).
fr: B<pthread_cond_wait>() déverrouille atomiquement le I<mutex> (comme B<pthread_unlock_mutex>()) et attend que la variable condition I<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 I<mutex> doit être verrouillé par le thread appelant à l'entrée de B<pthread_cond_wait>(). Avant de rendre la main au thread appelant, B<pthread_cond_wait>() re-verrouille I<mutex> (comme B<pthread_lock_mutex>()).

en: Unlocking the mutex and suspending on the condition variable is done atomically. Thus, if all threads always acquire the mutex before signaling the condition, this guarantees that the condition cannot be signaled (and thus ignored) between the time a thread locks the mutex and the time it waits on the condition variable.
fr: Le déverrouillage 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.

en: !pthread_cond_timedwait! atomically unlocks |mutex| and waits on |cond|, as !pthread_cond_wait! does, but it also bounds the duration of the wait. If |cond| has not been signaled within the amount of time specified by |abstime|, the mutex |mutex| is re-acquired and !pthread_cond_timedwait! returns the error !ETIMEDOUT!.  The |abstime| parameter specifies an absolute time, with the same origin as !time!(2) and !gettimeofday!(2): an |abstime| of 0 corresponds to 00:00:00 GMT, January 1, 1970.
fr: B<pthread_cond_timedwait>() déverrouille le I<mutex> et attend sur I<cond>, en liant atomiquement ces deux étapes, comme le fait B<pthread_cond_wait>(), cependant l'attente est bornée temporellement. Si I<cond> n'a pas été signalée après la période spécifiée par I<abstime>, le mutex I<mutex> est reverrouillé et B<pthread_cond_timedwait>() rend la main avec l'erreur B<ETIMEDOUT>. Le paramètre I<abstime> spécifie un temps absolu, avec la même origine que B<time>(2) et B<gettimeofday>(2)\ : un I<abstime> de 0 correspond à 00:00:00 GMT, le 1er Janvier 1970.

en: !pthread_cond_destroy! destroys a condition variable, freeing the resources it might hold. No threads must be waiting on the condition variable on entrance to !pthread_cond_destroy!. In the LinuxThreads implementation, no resources are associated with condition variables, thus !pthread_cond_destroy! actually does nothing except checking that the condition has no waiting threads.
fr: B<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 B<pthread_cond_destroy>(). Dans l'implémentation LinuxThreads, aucune ressource ne peut être associée à une variable condition, aussi B<pthread_cond_destroy>() ne fait en fait rien d'autre que vérifier qu'aucun thread n'attend la condition.

en: CANCELLATION
fr: ANNULATION

en: !pthread_cond_wait! and !pthread_cond_timedwait! are cancellation points. If a thread is cancelled while suspended in one of these functions, the thread immediately resumes execution, then locks again the |mutex| argument to !pthread_cond_wait! and !pthread_cond_timedwait!, and finally executes the cancellation.  Consequently, cleanup handlers are assured that |mutex| is locked when they are called.
fr: B<pthread_cond_wait>() et B<pthread_cond_timedwait>() sont des points d'annulation. Si un thread est annulé alors qu'il est suspendu dans l'une de ces fonctions, son exécution reprend immédiatement, re-verrouillant le paramètre I<mutex> à B<pthread_cond_wait>() et B<pthread_cond_timedwait>(), et exécute finalement l'annulation. Aussi, les gestionnaires d'annulation sont assurés que I<mutex> est verrouillé lorsqu'ils sont exécutés.

en: The condition functions are not async-signal safe, and should not be called from a signal handler. In particular, calling !pthread_cond_signal! or !pthread_cond_broadcast! from a signal handler may deadlock the calling thread.
fr: Ces fonctions ne sont pas fiables par rapport aux signaux asynchrones et ne doivent donc pas être utilisées dans des gestionnaires de signaux [Ndt\ : sous peine de perdre leur propriété d'atomicité]. En particulier, appeler B<pthread_cond_signal>() ou B<pthread_cond_broadcast>() dans un gestionnaire de signal peut placer le thread appelant dans une situation de blocage définitif.

en: All condition variable functions return 0 on success and a non-zero error code on error.
fr: Toutes ces fonctions renvoient 0 en cas de succès et un code d'erreur non nul en cas de problème.

en: !pthread_cond_init!, !pthread_cond_signal!, !pthread_cond_broadcast!, and !pthread_cond_wait! never return an error code.
fr: B<pthread_cond_init>(), B<pthread_cond_signal>(), B<pthread_cond_broadcast>(), et B<pthread_cond_wait>() ne renvoient jamais de code d'erreur.

en: The !pthread_cond_timedwait! function returns the following error codes on error:
fr: La fonction B<pthread_cond_timedwait>() renvoie l'un des codes d'erreur suivants en cas de problème\ :

en: !ETIMEDOUT!
fr: B<ETIMEDOUT>

en: the condition variable was not signaled until the timeout specified by |abstime|
fr: La variable condition n'a pas reçu de signal avant le délai spécifié par I<abstime>.

en: !EINTR!
fr: B<EINTR>

en: !pthread_cond_timedwait! was interrupted by a signal
fr: B<pthread_cond_timedwait>() a été interrompu par un signal.

en: The !pthread_cond_destroy! function returns the following error code on error:
fr: La fonction B<pthread_cond_destroy>() renvoie le code d'erreur suivant en cas de problème\ :

en: !EBUSY!
fr: B<EBUSY>

en: some threads are currently waiting on |cond|.
fr: Il existe des threads attendant I<cond>.

en: !pthread_condattr_init!(3), !pthread_mutex_lock!(3), !pthread_mutex_unlock!(3), !gettimeofday!(2), !nanosleep!(2).
fr: B<pthread_condattr_init>(3), B<pthread_mutex_lock>(3), B<pthread_mutex_unlock>(3), B<gettimeofday>(2), B<nanosleep>(2)

en: Consider two shared variables |x| and |y|, protected by the mutex |mut|, and a condition variable |cond| that is to be signaled whenever |x| becomes greater than |y|.
fr: Considérons deux variables globales partagées I<x> et I<y>, protégées par le mutex I<mut>, et une variable condition I<cond> pour signaler que I<x> devient plus grand que I<y>.

en: Waiting until |x| is greater than |y| is performed as follows:
fr: Attendre que I<x> devienne plus grand que I<y> se réalise de la manière suivante\ :

en: B<pthread_mutex_lock(&mut);
    while (x E<lt>= y) {
            pthread_cond_wait(&cond, &mut);
    }
    /* operate on x and y */
    pthread_mutex_unlock(&mut);>
fr: B<pthread_mutex_lock(&mut);
    while (x E<lt>= y) {
            pthread_cond_wait(&cond, &mut);
    }
    /* agir sur x et y */
    pthread_mutex_unlock(&mut);>

en: Modifications on |x| and |y| that may cause |x| to become greater than |y| should signal the condition if needed:
fr: Les modifications de I<x> et I<y> qui peuvent rendre I<x> plus grand que I<y> doivent signaler la condition si nécessaire\ :

en: B<pthread_mutex_lock(&mut);
    /* modify x and y */
    if (x E<gt> y) pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mut);>
fr: B<pthread_mutex_lock(&mut);
    /* modifie x et y */
    if (x E<gt> y) pthread_cond_broadcast(&cond);
    pthread_mutex_unlock(&mut);>

en: If it can be proved that at most one waiting thread needs to be waken up (for instance, if there are only two threads communicating through |x| and |y|), !pthread_cond_signal! can be used as a slightly more efficient alternative to !pthread_cond_broadcast!. In doubt, use !pthread_cond_broadcast!.
fr: S'il peut être prouvé qu'au plus un thread en attente nécessite d'être réveillé (par exemple, s'il n'y a que deux threads communicant via I<x> et I<y>), B<pthread_cond_signal>() peut être utilisé en tant qu'alternative efficace à B<pthread_cond_broadcast>(). En cas de doute, utilisez B<pthread_cond_broadcast>().

en: To wait for |x| to becomes greater than |y| with a timeout of 5 seconds, do:
fr: Pour attendre que I<x> devienne plus grand que I<y> avec un timeout de 5 secondes, faîtes\ :

en: B<pthread_mutex_lock(&mut);
    gettimeofday(&now);
    timeout.tv_sec = now.tv_sec + 5;
    timeout.tv_nsec = now.tv_usec * 1000;
    retcode = 0;
    while (x E<lt>= 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);>
fr: B<pthread_mutex_lock(&mut);
    gettimeofday(&now);
    timeout.tv_sec = now.tv_sec + 5;
    timeout.tv_nsec = now.tv_usec * 1000;
    retcode = 0;
    while (x E<lt>= y && retcode != ETIMEDOUT) {
            retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
    }
    if (retcode == ETIMEDOUT) {
            /* timeout */
    } else {
            /* agir sur x et y */
    }
    pthread_mutex_unlock(&mut);>
