fr - en to fr translation catalogue (94 entries)

en: NAME
fr: NOM

en: pthread_join - wait for termination of another thread
fr: pthread_join - Attendre la fin d'un autre thread

en: !pthread_join! suspends the execution of the calling thread until the thread identified by |th| terminates, either by calling !pthread_exit!(3)  or by being cancelled.
fr: B<pthread_join>() suspend l'exécution du thread appelant jusqu'à ce que le thread identifié par I<th> achève son exécution, soit en appelant B<pthread_exit>(3), soit après avoir été annulé.

en: If |thread_return| is not !NULL!, the return value of |th| is stored in the location pointed to by |thread_return|.  The return value of |th| is either the argument it gave to !pthread_exit!(3), or !PTHREAD_CANCELED! if |th| was cancelled.
fr: Si I<thread_return> ne vaut pas B<NULL>, la valeur renvoyée par I<th> y sera enregistrée. Cette valeur sera soit le paramètre passé à B<pthread_exit>(3), soit B<PTHREAD_CANCELED> si le thread I<th> a été annulé.

en: The joined thread !th! must be in the joinable state: it must not have been detached using !pthread_detach!(3) or the !PTHREAD_CREATE_DETACHED! attribute to !pthread_create!(3).
fr: Le thread joint B<th> doit être dans l'état joignable\ : il ne doit pas avoir été détaché par B<pthread_detach>(3) ou par l'attribut B<PTHREAD_CREATE_DETACHED> lors de sa création par B<pthread_create>(3).

en: When a joinable thread terminates, its memory resources (thread descriptor and stack) are not deallocated until another thread performs !pthread_join! on it. Therefore, !pthread_join! must be called once for each joinable thread created to avoid memory leaks.
fr: Quand l'exécution d'un thread joignable s'achève, ses ressources mémoire (descripteur de thread et pile) ne sont pas désallouées jusqu'à ce qu'un autre thread le joigne en utilisant B<pthread_join>(). Aussi, B<pthread_join>() doit être appelée une fois pour chaque thread joignable pour éviter des fuites de mémoire.

en: At most one thread can wait for the termination of a given thread. Calling !pthread_join! on a thread |th| on which another thread is already waiting for termination returns an error.
fr: Au plus un seul thread peut attendre la mort d'un thread donné. Appeler B<pthread_join>() sur un thread I<th> dont un autre thread attend déjà la fin renvoie une erreur.

en: CANCELLATION
fr: ANNULATION

en: !pthread_join! is a cancellation point. If a thread is canceled while suspended in !pthread_join!, the thread execution resumes immediately and the cancellation is executed without waiting for the |th| thread to terminate. If cancellation occurs during !pthread_join!, the |th| thread remains not joined.
fr: B<pthread_join> est un point d'annulation. Si un thread est annulé alors qu'il est suspendu dans B<pthread_join>(), l'exécution du thread reprend immédiatement et l'annulation est réalisée sans attendre la fin du thread I<th>. Si l'annulation intervient durant B<pthread_join>(), le thread I<th> demeure non joint.

en: RETURN VALUE
fr: VALEUR RENVOYÉE

en: On success, the return value of |th| is stored in the location pointed to by |thread_return|, and 0 is returned. On error, a non-zero error code is returned.
fr: En cas de succès, le code renvoyé par I<th> est enregistré à l'emplacement pointé par I<thread_return>, et 0 est renvoyé. En cas d'erreur, un code d'erreur non nul est renvoyé.

en: ERRORS
fr: ERREURS

en: !ESRCH!
fr: B<ESRCH>

en: No thread could be found corresponding to that specified by |th|.
fr: Aucun thread correspondant à I<th> n'a pu être trouvé.

en: !EINVAL!
fr: B<EINVAL>

en: The |th| thread has been detached.
fr: Le thread I<th> a été détaché.

en: Another thread is already waiting on termination of |th|.
fr: Un autre thread attend déjà la mort de I<th>.

en: !EDEADLK!
fr: B<EDEADLK>

en: The |th| argument refers to the calling thread.
fr: Le paramètre I<th> représente le thread appelant.

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: !pthread_exit!(3), !pthread_detach!(3), !pthread_create!(3), !pthread_attr_setdetachstate!(3), !pthread_cleanup_push!(3), !pthread_key_create!(3).
fr: B<pthread_exit>(3), B<pthread_detach>(3), B<pthread_create>(3), B<pthread_attr_setdetachstate>(3), B<pthread_cleanup_push>(3), B<pthread_key_create>(3).

en: pthread_key_create, pthread_key_delete, pthread_setspecific, pthread_getspecific - management of thread-specific data
fr: pthread_key_create, pthread_key_delete, pthread_setspecific, pthread_getspecific - Gestion de données spécifiques à un thread

en: Programs often need global or static variables that have different values in different threads. Since threads share one memory space, this cannot be achieved with regular variables. Thread-specific data is the POSIX threads answer to this need.
fr: Les programmes ont souvent besoin de variables globales ou statiques ayant différentes valeurs dans des threads différents. Comme les threads partagent le même espace mémoire, cet objectif ne peut être réalisé avec les variables usuelles. Les données spécifiques à un thread POSIX sont la réponse à ce problème.

en: Each thread possesses a private memory block, the thread-specific data area, or TSD area for short. This area is indexed by TSD keys. The TSD area associates values of type !void *! to TSD keys. TSD keys are common to all threads, but the value associated with a given TSD key can be different in each thread.
fr: Chaque thread possède un segment mémoire privé, le TSD (Thread-Specific Data\ : Données Spécifiques au Thread). Cette zone mémoire est indexée par des clés TSD. La zone TSD associe des valeurs du type B<void *> aux clés TSD. Ces clés sont communes à tous les threads, mais la valeur associée à une clé donnée est différente dans chaque thread.

en: For concreteness, the TSD areas can be viewed as arrays of !void *! pointers, TSD keys as integer indices into these arrays, and the value of a TSD key as the value of the corresponding array element in the calling thread.
fr: Pour concrétiser ce formalisme, les zones TSD peuvent être vues comme des tableaux de pointeurs B<void *>, les clés TSD comme des indices entiers pour ces tableaux, et les valeurs des clés TSD comme les valeurs des entrées correspondantes dans le tableau du thread appelant.

en: When a thread is created, its TSD area initially associates !NULL! with all keys.
fr: Quand un thread est créé, sa zone TSD associe initialement B<NULL> à toutes les clés.

en: !pthread_key_create! allocates a new TSD key. The key is stored in the location pointed to by |key|. There is a limit of !PTHREAD_KEYS_MAX! on the number of keys allocated at a given time. The value initially associated with the returned key is !NULL! in all currently executing threads.
fr: B<pthread_key_create>() alloue une nouvelle clé TSD. Cette clé est enregistrée à l'emplacement pointée par I<key>. Il ne peut y avoir plus de B<PTHREAD_KEYS_MAX> clés allouées à un instant donné. La valeur initialement associée avec la clé renvoyée est B<NULL> dans tous les threads en cours d'exécution.

en: The |destr_function| argument, if not !NULL!, specifies a destructor function associated with the key. When a thread terminates via !pthread_exit! or by cancellation, |destr_function| is called with arguments the value associated with the key in that thread. The |destr_function| is not called if that value is !NULL!. The order in which destructor functions are called at thread termination time is unspecified.
fr: Le paramètre I<destr_function>, si différent de B<NULL>, spécifie une fonction de destruction associée à une clé. Quand le thread se termine par B<pthread_exit>() ou par une annulation, I<destr_function> est appelée avec en argument les valeurs associées aux clés de ce thread. La fonction I<destr_function> n'est pas appelée si cette valeur est B<NULL>. L'ordre dans lequel les fonctions de destruction sont appelées lors de la fin du thread n'est pas spécifiée.

en: Before the destructor function is called, the !NULL! value is associated with the key in the current thread.  A destructor function might, however, re-associate non-!NULL! values to that key or some other key.  To deal with this, if after all the destructors have been called for all non-!NULL! values, there are still some non-!NULL! values with associated destructors, then the process is repeated.  The LinuxThreads implementation stops the process after !PTHREAD_DESTRUCTOR_ITERATIONS! iterations, even if some non-!NULL! values with associated descriptors remain.  Other implementations may loop indefinitely.
fr: Avant que la fonction de destruction soit appelée, la valeur B<NULL> est associée à la clé dans le thread courant. Une fonction de destruction peut cependant réassocier une valeur différente de B<NULL> à cette clé ou une autre clé. Pour gérer ce cas de figure, si après l'appel de tous les destructeurs pour les valeurs différentes de B<NULL>, il existe toujours des valeurs différentes de B<NULL> avec des destructeurs associés, alors la procédure est répétée. L'implémentation de LinuxThreads interrompt cette procédure après B<PTHREAD_DESTRUCTOR_ITERATIONS> itérations, même s'il reste des valeurs différentes de B<NULL> associées à des descripteurs. Les autres implémentations peuvent boucler sans fin.

en: !pthread_key_delete! deallocates a TSD key. It does not check whether non-!NULL! values are associated with that key in the currently executing threads, nor call the destructor function associated with the key.
fr: B<pthread_key_delete>() désalloue une clé TSD. Elle ne vérifie pas si des valeurs différentes de B<NULL> sont associées avec cette clé dans les threads en cours d'exécution, ni n'appelle la fonction de destruction associée avec cette clé.

en: !pthread_setspecific! changes the value associated with |key| in the calling thread, storing the given |pointer| instead.
fr: B<pthread_setspecific>() change la valeur associée avec I<clé> dans le thread appelant, sauve le paramètre I<pointer> à sa place.

en: !pthread_getspecific! returns the value currently associated with |key| in the calling thread.
fr: B<pthread_getspecific>() renvoie la valeur actuellement associée avec I<key> dans le thread appelant.

en: !pthread_key_create!, !pthread_key_delete!, and !pthread_setspecific! return 0 on success and a non-zero error code on failure. If successful, !pthread_key_create! stores the newly allocated key in the location pointed to by its |key| argument.
fr: B<pthread_key_create>(), B<pthread_key_delete>() et B<pthread_setspecific>() renvoient 0 en cas de succès et un code d'erreur non nul en cas d'échec. En cas de succès, B<pthread_key_create>() enregistre la clé récemment créée à l'emplacement pointé par son argument I<key>.

en: !pthread_getspecific! returns the value associated with |key| on success, and !NULL! on error.
fr: B<pthread_getspecific>() renvoie la valeur associée à I<clé> en cas de succès et B<NULL> en cas d'erreur.

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

en: !EAGAIN!
fr: B<EAGAIN>

en: !PTHREAD_KEYS_MAX! keys are already allocated
fr: B<PTHREAD_KEYS_MAX> clés sont déjà allouées.

en: !pthread_key_delete! and !pthread_setspecific! return the following error code on error:
fr: B<pthread_key_delete>() et B<pthread_setspecific>() renvoient le code d'erreur suivant\ :

en: |key| is not a valid, allocated TSD key
fr: I<key> n'est pas une clé TSD allouée valable.

en: !pthread_getspecific! returns !NULL! if |key| is not a valid, allocated TSD key.
fr: B<pthread_getspecific>() renvoie B<NULL> si I<key> n'est pas une clef TSD allouée valable.

en: pthread_create(3), pthread_exit(3), pthread_testcancel(3).
fr: B<pthread_create>(3), B<pthread_exit>(3), B<pthread_testcancel>(3).

en: EXAMPLE
fr: EXEMPLE

en: The following code fragment allocates a thread-specific array of 100 characters, with automatic reclaimation at thread exit:
fr: L'extrait de code suivant alloue dans un thread un tableau de 100 caractères, avec libération de la mémoire automatiquement à la fin de l'exécution du thread.

en: pthread_kill_other_threads_np - terminate all threads in program except calling thread
fr: pthread_kill_other_threads_np - Interrompre tous les autres threads du processus

en: !pthread_kill_other_threads_np! is a non-portable LinuxThreads extension.  It causes all threads in the program to terminate immediately, except the calling thread which proceeds normally. It is intended to be called just before a thread calls one of the !exec! functions, e.g. !execve!(2).
fr: B<pthread_kill_other_threads_np>() est une extension non portable de LinuxThreads. Tous les threads du processus sont immédiatement interrompus, excepté le thread appelant qui continue à s'exécuter. Cette fonction est fournie pour être exécutée juste avant qu'un thread appelle l'une des fonctions de la famille B<exec>, par exemple, B<execve>(2).

en: Termination of the other threads is not performed through !pthread_cancel!(3) and completely bypasses the cancellation mechanism. Hence, the current settings for cancellation state and cancellation type are ignored, and the cleanup handlers are not executed in the terminated threads.
fr: L'interruption des autres threads n'est pas réalisée via B<pthread_cancel>(3) et ignore les mécanismes d'annulation. Ainsi, les paramètres courants pour l'état et le type d'annulation sont ignorés et les gestionnaires de nettoyage ne sont pas exécutés dans les threads dont l'exécution s'achève.

en: !execve!(2), !pthread_setcancelstate!(3), !pthread_setcanceltype!(3), !pthread_cancel!(3).
fr: B<execve>(2), B<pthread_setcancelstate>(3), B<pthread_setcanceltype>(3), B<pthread_cancel>(3).

en: BUGS
fr: BOGUES

en: According to POSIX 1003.1c, a successful !exec*! in one of the threads should terminate automatically all other threads in the program.  This behavior is not yet implemented in LinuxThreads.  Calling !pthread_kill_other_threads_np! before !exec*! achieves much of the same behavior, except that if !exec*! ultimately fails, then all other threads are already killed.
fr: D'après POSIX 1003.1c, un appel couronné de succès à B<exec*> dans l'un des threads devrait terminer automatiquement tous les autres threads du programme. Ce comportement n'est pas encore implémenté dans LinuxThreads. Appeler B<pthread_kill_other_threads_np>() avant B<exec*> revient au même, excepté que si B<exec*> échoue, alors tous les autres threads ont déjà été interrompus.

en: pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, pthread_mutex_destroy - operations on mutexes
fr: pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, pthread_mutex_destroy - Opérations sur les mutex

en: A mutex is a MUTual EXclusion device, and is useful for protecting shared data structures from concurrent modifications, and implementing critical sections and monitors.
fr: Un mutex est un objet d'exclusion mutuelle (MUTual EXclusion), et il est très pratique pour protéger des données partagées de modifications simultanées et pour implémenter des sections critiques et moniteurs.

en: A mutex has two possible states: unlocked (not owned by any thread), and locked (owned by one thread). A mutex can never be owned by two different threads simultaneously. A thread attempting to lock a mutex that is already locked by another thread is suspended until the owning thread unlocks the mutex first.
fr: Un mutex peut être dans deux états\ : déverrouillé (pris par aucun thread) ou verrouillé (pris par un thread). Un mutex ne peut être pris que par un seul thread à la fois. Un thread qui tente de verrouiller un mutex déjà verrouillé est suspendu jusqu'à ce que le mutex soit déverrouillé.

en: !pthread_mutex_init! initializes the mutex object pointed to by |mutex| according to the mutex attributes specified in |mutexattr|.  If |mutexattr| is !NULL!, default attributes are used instead.
fr: B<pthread_mutex_init>() initialise le mutex pointé par I<mutex> selon les attributs de mutex spécifié par I<mutexattr>. Si I<mutexattr> vaut B<NULL>, les paramètres par défaut sont utilisés.

en: The LinuxThreads implementation supports only one mutex attributes, the |mutex kind|, which is either ``fast'', ``recursive'', or ``error checking''. The kind of a mutex determines whether it can be locked again by a thread that already owns it.  The default kind is ``fast''. See !pthread_mutexattr_init!(3) for more information on mutex attributes.
fr: L'implémentation LinuxThreads ne gère qu'un seul attribut, le I<type de mutex>, qui peut être soit «\ rapide\ », «\ récursif\ » ou à «\ vérification d'erreur\ ». Le type de mutex détermine s'il peut être verrouillé plusieurs fois par le même thread. Le type par défaut est «\ rapide\ ». Voyez B<pthread_mutexattr_init>(3) pour plus d'informations sur les attributs de mutex.

en: Variables of type !pthread_mutex_t! can also be initialized statically, using the constants !PTHREAD_MUTEX_INITIALIZER! (for fast mutexes), !PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP! (for recursive mutexes), and !PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP! (for error checking mutexes).
fr: Les variables de type B<pthread_mutex_t> peuvent aussi être initialisées de manière statique, en utilisant les constantes B<PTHREAD_MUTEX_INITIALIZER> (pour les mutex «\ rapides\ »), B<PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP> (pour les mutex «\ récursifs\ ») et B<PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP> (pour les mutex à «\ vérification d'erreur\ »).

en: !pthread_mutex_lock! locks the given mutex. If the mutex is currently unlocked, it becomes locked and owned by the calling thread, and !pthread_mutex_lock! returns immediately. If the mutex is already locked by another thread, !pthread_mutex_lock! suspends the calling thread until the mutex is unlocked.
fr: B<pthread_mutex_lock>() verrouille le mutex. Si le mutex est déverrouillé, il devient verrouillé et il est possédé par le thread appelant et B<pthread_mutex_lock>() rend la main immédiatement. Si le mutex est déjà verrouillé par un autre thread, B<pthread_mutex_lock> suspend le thread appelant jusqu'à ce que le mutex soit déverrouillé.

en: If the mutex is already locked by the calling thread, the behavior of !pthread_mutex_lock! depends on the kind of the mutex. If the mutex is of the ``fast'' kind, the calling thread is suspended until the mutex is unlocked, thus effectively causing the calling thread to deadlock. If the mutex is of the ``error checking'' kind, !pthread_mutex_lock! returns immediately with the error code !EDEADLK!.  If the mutex is of the ``recursive'' kind, !pthread_mutex_lock! succeeds and returns immediately, recording the number of times the calling thread has locked the mutex. An equal number of !pthread_mutex_unlock! operations must be performed before the mutex returns to the unlocked state.
fr: Si le mutex est déjà verrouillé par le thread appelant, le comportement de B<pthread_mutex_lock>() dépend du type du mutex. Si ce dernier est de type «\ rapide\ », le thread appelant est suspendu jusqu'à ce que le mutex soit déverrouillé, plaçant ainsi le thread appelant en situation de blocage définitif. Si le mutex est de type «\ vérification d'erreur\ », B<pthread_mutex_lock>() rend la main immédiatement avec le code d'erreur B<EDEADLK>. Si le mutex est de type «\ récursif\ », B<pthread_mutex_lock>() rend la main immédiatement avec un code de retour indiquant le succès, enregistrant le nombre de fois où le thread appelant a verrouillé le mutex. Un nombre égal d'appels à B<pthread_mutex_unlock>() doit être réalisé avant que le mutex retourne à l'état déverrouillé.

en: !pthread_mutex_trylock! behaves identically to !pthread_mutex_lock!, except that it does not block the calling thread if the mutex is already locked by another thread (or by the calling thread in the case of a ``fast'' mutex). Instead, !pthread_mutex_trylock! returns immediately with the error code !EBUSY!.
fr: B<pthread_mutex_trylock>() se comporte de la même manière que B<pthread_mutex_lock>(), excepté qu'elle ne bloque pas le thread appelant si le mutex est déjà verrouillé par un autre thread (ou par le thread appelant dans le cas d'un mutex «\ rapide\ »). Au contraire, B<pthread_mutex_trylock>() rend la main immédiatement avec le code d'erreur B<EBUSY>.

en: !pthread_mutex_unlock! unlocks the given mutex. The mutex is assumed to be locked and owned by the calling thread on entrance to !pthread_mutex_unlock!. If the mutex is of the ``fast'' kind, !pthread_mutex_unlock! always returns it to the unlocked state. If it is of the ``recursive'' kind, it decrements the locking count of the mutex (number of !pthread_mutex_lock! operations performed on it by the calling thread), and only when this count reaches zero is the mutex actually unlocked.
fr: B<pthread_mutex_unlock>() déverrouille le mutex. Celui-ci est supposé verrouillé, et ce par le thread courant en entrant dans B<pthread_mutex_unlock>(). Si le mutex est de type «\ rapide\ », B<pthread_mutex_unlock>() le réinitialise toujours à l'état déverrouillé. S'il est de type «\ récursif\ », son compteur de verrouillage est décrémenté (nombre d'opérations B<pthread_mutex_lock>() réalisées sur le mutex par le thread appelant), et déverrouillé seulement quand ce compteur atteint 0.

en: On ``error checking'' mutexes, !pthread_mutex_unlock! actually checks at run-time that the mutex is locked on entrance, and that it was locked by the same thread that is now calling !pthread_mutex_unlock!.  If these conditions are not met, an error code is returned and the mutex remains unchanged.  ``Fast'' and ``recursive'' mutexes perform no such checks, thus allowing a locked mutex to be unlocked by a thread other than its owner. This is non-portable behavior and must not be relied upon.
fr: Sur les mutex «\ vérification d'erreur\ », B<pthread_mutex_unlock>() vérifie lors de l'exécution que le mutex est verrouillé en entrant, et qu'il est verrouillé par le même thread que celui appelant B<pthread_mutex_unlock>() Si ces conditions ne sont pas réunies, un code d'erreur est renvoyé et le mutex n'est pas modifié. Les mutex «\ rapide\ » et «\ récursif\ » ne réalisent pas de tels tests, permettant à un mutex verrouillé d'être déverrouillé par un thread autre que celui l'ayant verrouillé. Ce comportement n'est pas portable et l'on ne doit pas compter dessus.

en: !pthread_mutex_destroy! destroys a mutex object, freeing the resources it might hold. The mutex must be unlocked on entrance. In the LinuxThreads implementation, no resources are associated with mutex objects, thus !pthread_mutex_destroy! actually does nothing except checking that the mutex is unlocked.
fr: B<pthread_mutex_destroy>() détruit un mutex, libérant les ressources qu'il détient. Le mutex doit être déverrouillé. Dans l'implémentation LinuxThreads, aucune ressource ne peut être associée à un mutex, aussi B<pthread_mutex_destroy>() ne fait rien si ce n'est vérifier que le mutex n'est pas verrouillé.

en: None of the mutex functions is a cancellation point, not even !pthread_mutex_lock!, in spite of the fact that it can suspend a thread for arbitrary durations. This way, the status of mutexes at cancellation points is predictable, allowing cancellation handlers to unlock precisely those mutexes that need to be unlocked before the thread stops executing. Consequently, threads using deferred cancellation should never hold a mutex for extended periods of time.
fr: Aucune des primitives relatives aux mutex n'est un point d'annulation, ni même B<pthread_mutex_lock>(), malgré le fait qu'il peut suspendre l'exécution du thread pour une longue durée. De cette manière, le statut des mutex aux points d'annulation est prévisible, permettant aux gestionnaires d'annulation de déverrouiller précisément ces mutex qui nécessitent d'être déverrouillés avant que l'exécution du thread ne s'arrête définitivement. Aussi, les threads travaillant en mode d'annulation retardée ne doivent-jamais verrouiller un mutex pour de longues périodes de temps.

en: The mutex functions are not async-signal safe. What this means is that they should not be called from a signal handler. In particular, calling !pthread_mutex_lock! or !pthread_mutex_unlock! from a signal handler may deadlock the calling thread.
fr: Les fonctions relatives aux mutex ne sont pas fiables par rapport aux signaux asynchrones et ne doivent donc pas être utilisées dans des gestionnaires de signaux. En particulier, appeler B<pthread_mutex_lock>() ou B<pthread_mutex_unlock>() dans un gestionnaire de signal peut placer le thread appelant dans une situation de blocage définitif.

en: !pthread_mutex_init! always returns 0. The other mutex functions return 0 on success and a non-zero error code on error.
fr: B<pthread_mutex_init>() retourne toujours 0. Les autres fonctions renvoient 0 en cas de succès et un code d'erreur non nul en cas de problème.

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

en: the mutex has not been properly initialized.
fr: Le mutex n'a pas été initialisé.

en: the mutex is already locked by the calling thread (``error checking'' mutexes only).
fr: Le mutex est déjà verrouillé par un thread autre que l'appelant (mutex à «\ vérification d'erreur\ » seulement).

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

en: !EBUSY!
fr: B<EBUSY>

en: the mutex could not be acquired because it was currently locked.
fr: Le mutex ne peut être verrouillé car il l'est déjà.

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

en: !EPERM!
fr: B<EPERM>

en: the calling thread does not own the mutex (``error checking'' mutexes only).
fr: Le thread appelant ne possède pas le mutex (mutex à «\ vérification d'erreur\ » seulement).

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

en: the mutex is currently locked.
fr: Le mutex est déjà verrouillé.

en: !pthread_mutexattr_init!(3), !pthread_mutexattr_setkind_np!(3), !pthread_cancel!(3).
fr: B<pthread_mutexattr_init>(3), B<pthread_mutexattr_setkind_np>(3), B<pthread_cancel>(3).

en: A shared global variable |x| can be protected by a mutex as follows:
fr: Une variable globale partagée I<x> peut être protégée par un mutex comme suit\ :

en: All accesses and modifications to |x| should be bracketed by calls to !pthread_mutex_lock! and !pthread_mutex_unlock! as follows:
fr: Tous les accès et modifications de I<x> doivent être entourés de paires d'appels à B<pthread_mutex_lock>() et B<pthread_mutex_unlock>() comme suit\ :

en: pthread_mutexattr_init, pthread_mutexattr_destroy, pthread_mutexattr_settype, pthread_mutexattr_gettype - mutex creation attributes
fr: pthread_mutexattr_init, pthread_mutexattr_destroy, pthread_mutexattr_settype, pthread_mutexattr_gettype - Attributs de création de mutex

en: Mutex attributes can be specified at mutex creation time, by passing a mutex attribute object as second argument to !pthread_mutex_init!(3).  Passing !NULL! is equivalent to passing a mutex attribute object with all attributes set to their default values.
fr: Les attributs de création de mutex peuvent être spécifiés lors de leur création en les passant en tant que second argument à B<pthread_mutex_init>(3). Passer une valeur B<NULL> est équivalent à un objet attributs de mutex avec tous les attributs positionnés à leur valeur par défaut.

en: !pthread_mutexattr_init! initializes the mutex attribute object |attr| and fills it with default values for the attributes.
fr: B<pthread_mutexattr_init>() initialise l'objet attributs de mutex I<attr> et le remplit avec les valeurs par défaut.

en: !pthread_mutexattr_destroy! destroys a mutex attribute object, which must not be reused until it is reinitialized. !pthread_mutexattr_destroy! does nothing in the LinuxThreads implementation.
fr: B<pthread_mutexattr_destroy>() détruit un objet attributs de mutex qui ne doit plus jamais être utilisé à moins d'être réinitialisé. B<pthread_mutexattr_destroy>() ne fait rien dans l'implémentation LinuxThreads.

en: LinuxThreads supports only one mutex attribute: the mutex kind, which is either !PTHREAD_MUTEX_FAST_NP! for ``fast'' mutexes, !PTHREAD_MUTEX_RECURSIVE_NP! for ``recursive'' mutexes, or !PTHREAD_MUTEX_ERRORCHECK_NP! for ``error checking'' mutexes.  As the !NP! suffix indicates, this is a non-portable extension to the POSIX standard and should not be employed in portable programs.
fr: LinuxThreads supporte seulement un seul attribut de mutex\ : le type de mutex qui peut être soit B<PTHREAD_MUTEX_FAST_NP> pour des mutex «\ rapides\ », soit B<PTHREAD_MUTEX_RECURSIVE_NP> pour des mutex «\ récursifs\ », soit B<PTHREAD_MUTEX_ERRORCHECK_NP> pour des mutex avec «\ vérification d'erreur\ ». Comme le suffixe B<NP> l'indique, ce sont des extensions non portables aux spécifications POSIX et ne devraient donc jamais être employées dans un programme portable.

en: The mutex kind determines what happens if a thread attempts to lock a mutex it already owns with !pthread_mutex_lock!(3). If the mutex is of the ``fast'' kind, !pthread_mutex_lock!(3) simply suspends the calling thread forever.  If the mutex is of the ``error checking'' kind, !pthread_mutex_lock!(3) returns immediately with the error code !EDEADLK!.  If the mutex is of the ``recursive'' kind, the call to !pthread_mutex_lock!(3) returns immediately with a success return code. The number of times the thread owning the mutex has locked it is recorded in the mutex. The owning thread must call !pthread_mutex_unlock!(3) the same number of times before the mutex returns to the unlocked state.
fr: Le type de mutex détermine ce qu'il se passe si un thread essaye de verrouiller un mutex déjà verrouillé par B<pthread_mutex_lock>(3). Si le mutex est de type «\ rapide\ »; B<pthread_mutex_lock>(3) suspend simplement le thread appelant. Si le mutex est de type avec «\ vérification d'erreur\ », B<pthread_mutex_lock>(3) rend la main immédiatement avec le code d'erreur B<EDEADLK>. Si le mutex est de type «\ récursif\ », l'appel à B<pthread_mutex_lock>(3) rend la main immédiatement avec un code de retour de réussite. Le nombre de verrouillage par le thread possédant le mutex est enregistré dans le mutex. Le thread possédant le mutex doit appeler B<pthread_mutex_unlock>(3) le même nombre de fois afin que le mutex passe à l'état déverrouillé.

en: The default mutex kind is ``fast'', that is, !PTHREAD_MUTEX_FAST_NP!.
fr: Le type de mutex par défaut est «\ rapide\ », c'est-à-dire B<PTHREAD_MUTEX_FAST_NP>.

en: !pthread_mutexattr_settype! sets the mutex kind attribute in |attr| to the value specified by |kind|.
fr: B<pthread_mutexattr_settype>() modifie l'attribut type_de_mutex dans I<attr> à la valeur spécifiée par I<kind>.

en: !pthread_mutexattr_gettype! retrieves the current value of the mutex kind attribute in |attr| and stores it in the location pointed to by |kind|.
fr: B<pthread_mutexattr_gettype>() récupère la valeur courante de l'attribut type de mutex dans I<attr> et l'enregistre à l'emplacement pointé par I<kind>.

en: !pthread_mutexattr_init!, !pthread_mutexattr_destroy! and !pthread_mutexattr_gettype! always return 0.
fr: B<pthread_mutexattr_init>(), B<pthread_mutexattr_destroy>() et B<pthread_mutexattr_gettype>() renvoient toujours 0.

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

en: On error, !pthread_mutexattr_settype! returns the following error code:
fr: En cas d'erreur, B<pthread_mutexattr_settype>() renvoie le code d'erreur suivant\ :

en: |kind| is neither !PTHREAD_MUTEX_FAST_NP! nor !PTHREAD_MUTEX_RECURSIVE_NP! nor !PTHREAD_MUTEX_ERRORCHECK_NP!
fr: I<type> n'est ni B<PTHREAD_MUTEX_FAST_NP> ni B<PTHREAD_MUTEX_RECURSIVE_NP> ni B<PTHREAD_MUTEX_ERRORCHECK_NP>

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