Provided by: manpages-fr-dev_4.26.0-1_all 
NOM
pthread_setcancelstate, pthread_setcanceltype — Définir l'état et le type d'annulation
BIBLIOTHÈQUE
Bibliothèque de threads POSIX (libpthread, -lpthread)
SYNOPSIS
#include <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
DESCRIPTION
La fonction pthread_setcancelstate() définit l'état d'annulation du thread appelant à la valeur indiquée
par state. L'ancien état d'annulation du thread est renvoyé dans le tampon pointé par oldstate.
L'argument state doit avoir une des valeurs suivantes :
PTHREAD_CANCEL_ENABLE
Le thread peut être annulé. C'est l'état d'annulation par défaut pour tous les nouveaux threads, y
compris le thread initial. Le type d'annulation du thread détermine quand un thread annulable
répondra à une requête d'annulation.
PTHREAD_CANCEL_DISABLE
Le thread n'est pas annulable. Si une requête d'annulation arrive, elle est bloquée jusqu'à ce que
l'annulation soit activée.
La fonction pthread_setcanceltype() définit le type d'annulation du thread appelant à la valeur indiquée
par type. L'ancien type d'annulation du thread est renvoyé dans le tampon pointé par oldtype. L'argument
type doit avoir une des valeurs suivantes :
PTHREAD_CANCEL_DEFERRED
Une requête d'annulation est retardé jusqu'à ce que le thread appelle une fonction qui est un
point d'annulation (consultez pthreads(7)). C'est le type d'annulation par défaut pour tous les
nouveaux threads, y compris le thread initial.
Même avec une annulation retardée, un point d'annulation dans un gestionnaire de signal asynchrone
peut encore être pris en compte et l'effet est similaire à s'il s'agissait d'une annulation
asynchrone.
PTHREAD_CANCEL_ASYNCHRONOUS
Le thread peut être annulé à tout moment. Typiquement, il sera annulé dès réception de la requête
d'annulation, mais ce n'est pas garanti par le système.
Les opérations set/get effectuées par ces fonctions sont atomiques, eu égard aux autres threads du
processus qui appellent la même fonction.
VALEUR RENVOYÉE
En cas de succès, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un code d'erreur non nul.
ERREURS
pthread_setcancelstate() peut échouer avec l'erreur suivante :
EINVAL Valeur invalide pour state.
pthread_setcanceltype() peut échouer avec l'erreur suivante :
EINVAL Valeur invalide pour type.
ATTRIBUTS
Pour une explication des termes utilisés dans cette section, consulter attributes(7).
┌────────────────────────────────────────────────────────────────────┬────────────────────────┬─────────┐
│ Interface │ Attribut │ Valeur │
├────────────────────────────────────────────────────────────────────┼────────────────────────┼─────────┤
│ pthread_setcancelstate(), pthread_setcanceltype() │ Sécurité des threads │ MT-Safe │
├────────────────────────────────────────────────────────────────────┼────────────────────────┼─────────┤
│ pthread_setcancelstate(), pthread_setcanceltype() │ Sécurité signaux async │ AC-Safe │
└────────────────────────────────────────────────────────────────────┴────────────────────────┴─────────┘
STANDARDS
POSIX.1-2008.
HISTORIQUE
glibc 2.0 POSIX.1-2001.
NOTES
Pour des détails sur ce qui se passe quand un thread est annulé, voyez pthread_cancel(3).
Désactiver brièvement l'annulation peut être pratique si un thread effectue une action critique qui ne
doit pas être interrompue par une requête d'annulation. Mais attention de ne pas désactiver l'annulation
sur de longues périodes, ou autour d'opérations qui peuvent ploquer pendant un long moment, car cela
empêcherait le thread de répondre aux requêtes d'annulation.
Annulation asynchrone
Le type d'annulation est rarement mis à PTHREAD_CANCEL_ASYNCHRONOUS. Comme le thread pourrait être annulé
n'importe quand, il ne pourrait pas réserver de ressources (par exemple en allouant de la mémoire avec
malloc(3)) de manière sûre, acquérir des verrous exclusifs (mutex), des sémaphores, des verrous, etc.
Réserver des ressources n'est pas sûr, car l'application n'a aucun moyen de connaître l'état de ces
ressources quand le thread est annulé ; en d'autres termes, l'annulation arrive-t-elle avant que les
ressources n'aient été réservées, pendant qu'elles sont réservées, ou après qu'elles ont été libérées ?
De plus, certaines structures de données internes (par exemple la liste chaînée des blocs libres gérée
par la famille de fonctions malloc(3)) pourraient se retrouver dans un état incohérent si l'annulation se
passe au milieu d'un appel de fonction. En conséquence de quoi les gestionnaires de nettoyage perdent
toute utilité.
Les fonctions qui peuvent sans risque être annulées de manière asynchrone sont appelées des fonctions
async-cancel-safe. POSIX.1-2001 et POSIX.1-2008 nécessitent seulement que pthread_cancel(3),
pthread_setcancelstate() et pthread_setcanceltype() soient async-cancel-safe. En général, les autres
fonctions de la bibliothèque ne peuvent pas être appelées de manière sûre depuis un thread annulable
immédiatement.
Une des rares circonstances dans lesquelles une annulation immédiate est utile est pour l'annulation d'un
thread qui est dans une boucle qui ne fait que des calculs.
Notes sur la portabilité
Les implémentations de Linux autorisent l'argument oldstate de pthread_setcancelstate() à être NULL,
auquel cas l'information au sujet de l'état antérieur d'annulation n'est pas renvoyée à l'appelant.
Beaucoup d'autres implémentations autorisent aussi un argument oldstat NULL, mais POSIX.1 ne spécifie pas
ce point, si bien que les applications portables devraient toujours donner une valeur non NULL à
oldstate. Le même type de raisonnement s'applique à l'argument oldtype de pthread_setcanceltype().
EXEMPLES
Consultez pthread_cancel(3).
VOIR AUSSI
pthread_cancel(3), pthread_cleanup_push(3), pthread_testcancel(3), pthreads(7)
TRADUCTION
La traduction française de cette page de manuel a été créée par Christophe Blaess
<https://www.blaess.fr/christophe/>, Stéphan Rafin <stephan.rafin@laposte.net>, Thierry Vignaud
<tvignaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe Guérard
<fevrier@tigreraye.org>, Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau
<jcristau@debian.org>, Thomas Huriaux <thomas.huriaux@gmail.com>, Nicolas François
<nicolas.francois@centraliens.net>, Florentin Duneau <fduneau@gmail.com>, Simon Paillard
<simon.paillard@resel.enst-bretagne.fr>, Denis Barbier <barbier@debian.org>, David Prévot
<david@tilapin.org>, Frédéric Hantrais <fhantrais@gmail.com> et Jean-Pierre Giraud <jean-
pierregiraud@neuf.fr>
Cette traduction est une documentation libre ; veuillez vous reporter à la GNU General Public License
version 3 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.
Pages du manuel de Linux 6.9.1 2 mai 2024 pthread_setcancelstate(3)