.\" -*- coding: UTF-8 -*- .\"******************************************************************* .\" .\" This file was generated with po4a. Translate the source file. .\" .\"******************************************************************* .TH PTHREAD_MUTEX 3 LinuxThreads .SH NOM pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock, pthread_mutex_unlock, pthread_mutex_destroy \- Opérations sur les mutex .SH SYNOPSIS \fB#include <pthread.h>\fP \fBpthread_mutex_t \fP\fIfastmutex\fP\fB = PTHREAD_MUTEX_INITIALIZER;\fP \fBpthread_mutex_t \fP\fIrecmutex\fP\fB = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;\fP \fBpthread_mutex_t \fP\fIerrchkmutex\fP\fB = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;\fP \fBint pthread_mutex_init(pthread_mutex_t *\fP\fImutex\fP\fB, const pthread_mutexattr_t *\fP\fImutexattr\fP\fB);\fP \fBint pthread_mutex_lock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_trylock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_unlock(pthread_mutex_t *\fP\fImutex\fP\fB);\fP \fBint pthread_mutex_destroy(pthread_mutex_t *\fP\fImutex\fP\fB);\fP .SH DESCRIPTION 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. 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é. \fBpthread_mutex_init\fP() initialise le mutex pointé par \fImutex\fP selon les attributs de mutex spécifié par \fImutexattr\fP. Si \fImutexattr\fP vaut NULL, les paramètres par défaut sont utilisés. L'implémentation LinuxThreads ne gère qu'un seul attribut, le \fItype de mutex\fP, 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 \fBpthread_mutexattr_init\fP(3) pour plus d'informations sur les attributs de mutex. Les variables de type \fBpthread_mutex_t\fP peuvent aussi être initialisées de manière statique, en utilisant les constantes \fBPTHREAD_MUTEX_INITIALIZER\fP (pour les mutex «\ rapides\ »), \fBPTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP\fP (pour les mutex «\ récursifs\ ») et \fBPTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP\fP (pour les mutex à «\ vérification d'erreur\ »). \fBpthread_mutex_lock\fP() verrouille le mutex. Si le mutex est déverrouillé, il devient verrouillé et il est possédé par le thread appelant et \fBpthread_mutex_lock\fP() rend la main immédiatement. Si le mutex est déjà verrouillé par un autre thread, \fBpthread_mutex_lock\fP suspend le thread appelant jusqu'à ce que le mutex soit déverrouillé. Si le mutex est déjà verrouillé par le thread appelant, le comportement de \fBpthread_mutex_lock\fP() 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\ », \fBpthread_mutex_lock\fP() rend la main immédiatement avec le code d'erreur \fBEDEADLK\fP. Si le mutex est de type «\ récursif\ », \fBpthread_mutex_lock\fP() 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 à \fBpthread_mutex_unlock\fP() doit être réalisé avant que le mutex retourne à l'état déverrouillé. \fBpthread_mutex_trylock\fP() se comporte de la même manière que \fBpthread_mutex_lock\fP(), 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, \fBpthread_mutex_trylock\fP() rend la main immédiatement avec le code d'erreur \fBEBUSY\fP. \fBpthread_mutex_unlock\fP() déverrouille le mutex. Celui\-ci est supposé verrouillé, et ce par le thread courant en entrant dans \fBpthread_mutex_unlock\fP(). Si le mutex est de type «\ rapide\ », \fBpthread_mutex_unlock\fP() le réinitialise toujours à l'état déverrouillé. S'il est de type «\ récursif\ », son compteur de verrouillage est décrémenté (du nombre d'opérations \fBpthread_mutex_lock\fP() réalisées sur le mutex par le thread appelant), et déverrouillé seulement quand ce compteur atteint 0. Sur les mutex «\ vérification d'erreur\ » et «\ récursif\ », \fBpthread_mutex_unlock\fP() 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 \fBpthread_mutex_unlock\fP() Si ces conditions ne sont pas réunies, un code d'erreur est renvoyé et le mutex n'est pas modifié. Les mutex «\ rapides\ » 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. \fBpthread_mutex_destroy\fP() 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 \fBpthread_mutex_destroy\fP() ne fait rien si ce n'est vérifier que le mutex n'est pas verrouillé. .SH ANNULATION Aucune des primitives relatives aux mutex n'est un point d'annulation, ni même \fBpthread_mutex_lock\fP(), malgré le fait qu'il peut suspendre l'exécution du thread pour une longue durée. De cette manière, l'état 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. .SH "ASYNC\-SIGNAL SAFETY" 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 \fBpthread_mutex_lock\fP() ou \fBpthread_mutex_unlock\fP() dans un gestionnaire de signal peut placer le thread appelant dans une situation de blocage définitif. .SH "VALEUR RENVOYÉE" \fBpthread_mutex_init\fP() 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. .SH ERREURS La fonction \fBpthread_mutex_lock\fP() renvoie l'un des codes d'erreur suivants en cas de problème\ : .RS .TP \fBEINVAL\fP Le mutex n'a pas été initialisé. .TP \fBEDEADLK\fP Le mutex est déjà verrouillé par le thread appelant (mutex à «\ vérification d'erreur\ » seulement). .RE La fonction \fBpthread_mutex_trylock\fP() renvoie l'un des codes d'erreur suivants en cas de problème\ : .RS .TP \fBEBUSY\fP Le mutex ne peut être verrouillé car il l'est déjà. .TP \fBEINVAL\fP Le mutex n'a pas été initialisé. .RE La fonction \fBpthread_mutex_unlock\fP() renvoie le code d'erreur suivant en cas de problème\ : .RS .TP \fBEINVAL\fP Le mutex n'a pas été initialisé. .TP \fBEPERM\fP Le thread appelant ne possède pas le mutex (mutex à «\ vérification d'erreur\ » seulement). .RE La fonction \fBpthread_mutex_destroy\fP() renvoie le code d'erreur suivant en cas de problème\ : .RS .TP \fBEBUSY\fP Le mutex est déjà verrouillé. .RE .SH AUTEUR Xavier Leroy <Xavier.Leroy@inria.fr> .SH "VOIR AUSSI" \fBpthread_mutexattr_init\fP(3), \fBpthread_mutexattr_setkind_np\fP(3), \fBpthread_cancel\fP(3). .SH EXEMPLE Une variable globale partagée \fIx\fP peut être protégée par un mutex comme suit\ : .RS .nf .sp \fBint x; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;\fP .LP .RE .fi Tous les accès et modifications de \fIx\fP doivent être entourés de paires d'appels à \fBpthread_mutex_lock\fP() et \fBpthread_mutex_unlock\fP() comme suit\ : .RS .nf .sp \fBpthread_mutex_lock(&mut); /* operate on x */ pthread_mutex_unlock(&mut);\fP .LP .RE .fi .PP .SH TRADUCTION La traduction française de cette page de manuel a été créée par Gérard Delafond <gerard@delafond.org>, Christophe Blaess <ccb@club-internet.fr>, Thierry Vignaud <tvignaud@mandriva.com>, Alain Portal <aportal@univ-montp2.fr>, Denis Barbier <barbier@debian.org>, Nicolas François <nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Thomas Blein <tblein@tblein.eu> et David Prévot <david@tilapin.org> . .PP Cette traduction est une documentation libre ; veuillez vous reporter à la .UR https://www.gnu.org/licenses/gpl-3.0.html GNU General Public License version 3 .UE concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE. .PP Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message à .MT debian-l10n-french@lists.debian.org .ME .