PTHREAD_MUTEX(3) Library Functions Manual PTHREAD_MUTEX(3)
NOM
pthread_mutex_init, pthread_mutex_lock, pthread_mutex_trylock,
pthread_mutex_unlock, pthread_mutex_destroy - Opérations sur les mutex
SYNOPSIS
#include <pthread.h>
pthread_mutex_t fastmutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t recmutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP;
pthread_mutex_t errchkmutex = PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP;
int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mu-
texattr_t *mutexattr);
int pthread_mutex_lock(pthread_mutex_t *mutex);
int pthread_mutex_trylock(pthread_mutex_t *mutex);
int pthread_mutex_unlock(pthread_mutex_t *mutex);
int pthread_mutex_destroy(pthread_mutex_t *mutex);
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éver-
rouillé.
pthread_mutex_init() initialise le mutex pointé par mutex selon les at-
tributs de mutex spécifié par mutexattr. Si mutexattr vaut NULL, les
paramètres par défaut sont utilisés.
L'implémentation LinuxThreads ne gère qu'un seul attribut, le 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é plu-
sieurs fois par le même thread. Le type par défaut est « rapide ».
Voyez pthread_mutexattr_init(3) pour plus d'informations sur les attri-
buts de mutex.
Les variables de type pthread_mutex_t peuvent aussi être initialisées
de manière statique, en utilisant les constantes PTHREAD_MUTEX_INITIA-
LIZER (pour les mutex « rapides »), PTHREAD_RECURSIVE_MUTEX_INITIALI-
ZER_NP (pour les mutex « récursifs ») et PTHREAD_ERRORCHECK_MUTEX_INI-
TIALIZER_NP (pour les mutex à « vérification d'erreur »).
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
pthread_mutex_lock() rend la main immédiatement. Si le mutex est déjà
verrouillé par un autre thread, pthread_mutex_lock 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 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 mu-
tex 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 »,
pthread_mutex_lock() rend la main immédiatement avec le code d'erreur
EDEADLK. Si le mutex est de type « récursif », 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 à pthread_mutex_unlock() doit être réa-
lisé avant que le mutex retourne à l'état déverrouillé.
pthread_mutex_trylock() se comporte de la même manière que pthread_mu-
tex_lock(), excepté qu'elle ne bloque pas le thread appelant si le mu-
tex est déjà verrouillé par un autre thread (ou par le thread appelant
dans le cas d'un mutex « rapide »). Au contraire, pthread_mutex_try-
lock() rend la main immédiatement avec le code d'erreur EBUSY.
pthread_mutex_unlock() déverrouille le mutex. Celui-ci est supposé ver-
rouillé, et ce par le thread courant en entrant dans pthread_mutex_un-
lock(). Si le mutex est de type « rapide », pthread_mutex_unlock() le
réinitialise toujours à l'état déverrouillé. S'il est de type « récur-
sif », son compteur de verrouillage est décrémenté (du nombre d'opéra-
tions pthread_mutex_lock() réalisées sur le mutex par le thread appe-
lant), et déverrouillé seulement quand ce compteur atteint 0.
Sur les mutex « vérification d'erreur » et « récursif », pthread_mu-
tex_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
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 « ra-
pides » ne réalisent pas de tels tests, permettant à un mutex ver-
rouillé d'être déverrouillé par un thread autre que celui l'ayant ver-
rouillé. Ce comportement n'est pas portable et l'on ne doit pas compter
dessus.
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 Linux-
Threads, aucune ressource ne peut être associée à un mutex, aussi
pthread_mutex_destroy() ne fait rien si ce n'est vérifier que le mutex
n'est pas verrouillé.
ANNULATION
Aucune des primitives relatives aux mutex n'est un point d'annulation,
ni même pthread_mutex_lock(), 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 ges-
tionnaires 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'ar-
rête définitivement. Aussi, les threads travaillant en mode d'annula-
tion retardée ne doivent-jamais verrouiller un mutex pour de longues
périodes de temps.
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 ges-
tionnaires de signaux. En particulier, appeler pthread_mutex_lock() ou
pthread_mutex_unlock() dans un gestionnaire de signal peut placer le
thread appelant dans une situation de blocage définitif.
VALEUR RENVOYÉE
pthread_mutex_init() retourne toujours 0. Les autres fonctions ren-
voient 0 en cas de succès et un code d'erreur non nul en cas de pro-
blème.
ERREURS
La fonction pthread_mutex_lock() renvoie l'un des codes d'erreur sui-
vants en cas de problème :
EINVAL Le mutex n'a pas été initialisé.
EDEADLK
Le mutex est déjà verrouillé par le thread appelant (mu-
tex à « vérification d'erreur » seulement).
La fonction pthread_mutex_trylock() renvoie l'un des codes d'erreur
suivants en cas de problème :
EBUSY Le mutex ne peut être verrouillé car il l'est déjà.
EINVAL Le mutex n'a pas été initialisé.
La fonction pthread_mutex_unlock() renvoie le code d'erreur suivant en
cas de problème :
EINVAL Le mutex n'a pas été initialisé.
EPERM Le thread appelant ne possède pas le mutex (mutex à « vé-
rification d'erreur » seulement).
La fonction pthread_mutex_destroy() renvoie le code d'erreur suivant en
cas de problème :
EBUSY Le mutex est déjà verrouillé.
AUTEUR
Xavier Leroy <Xavier.Leroy@inria.fr>
VOIR AUSSI
pthread_mutexattr_init(3), pthread_mutexattr_setkind_np(3),
pthread_cancel(3).
EXEMPLE
Une variable globale partagée x peut être protégée par un mutex comme
suit :
int x; pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
Tous les accès et modifications de x doivent être entourés de paires
d'appels à pthread_mutex_lock() et pthread_mutex_unlock() comme suit :
pthread_mutex_lock(&mut); /* operate on x */ pthread_mutex_unlock(&mut);
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-inter-
net.fr>, Thierry Vignaud <tvignaud@mandriva.com>, Alain Portal <apor-
tal@univ-montp2.fr>, Denis Barbier <barbier@debian.org>, Nicolas Fran-
çois <nicolas.francois@centraliens.net>, Florentin Duneau <fdu-
neau@gmail.com>, Thomas Blein <tblein@tblein.eu> et David Prévot <da-
vid@tilapin.org>
Cette traduction est une documentation libre ; veuillez vous reporter à
la GNU General Public License version 3
⟨https://www.gnu.org/licenses/gpl-3.0.html⟩ concernant les conditions
de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.
Si vous découvrez un bogue dans la traduction de cette page de manuel,
veuillez envoyer un message à ⟨debian-l10n-french@lists.debian.org⟩.
LinuxThreads PTHREAD_MUTEX(3)
Generated by dwww version 1.15 on Sat Jun 29 00:27:12 CEST 2024.