Provided by: manpages-fr-dev_4.15.0-9_all 
NOM
pthread_setcancelstate, pthread_setcanceltype - Définir l'état et le type d'annulation
SYNOPSIS
#include <pthread.h>
int pthread_setcancelstate(int state, int *oldstate);
int pthread_setcanceltype(int type, int *oldtype);
Compiler et éditer les liens avec -pthreads.
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.
Even with deferred cancellation, a cancellation point in an asynchronous signal
handler may still be acted upon and the effect is as if it was an asynchronous
cancellation.
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() │ Async-cancel safety │ AC-Safe │
└────────────────────────────────────────────────────────┴──────────────────────┴─────────┘
CONFORMITÉ
POSIX.1-2001, POSIX.1-2008.
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é.
Functions that can be safely asynchronously canceled are called async-cancel-safe
functions. POSIX.1-2001 and POSIX.1-2008 require only that pthread_cancel(3),
pthread_setcancelstate(), and pthread_setcanceltype() be async-cancel-safe. In general,
other library functions can't be safely called from an asynchronously cancelable thread.
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é
The Linux threading implementations permit the oldstate argument of
pthread_setcancelstate() to be NULL, in which case the information about the previous
cancelability state is not returned to the caller. Many other implementations also permit
a NULL oldstat argument, but POSIX.1 does not specify this point, so portable applications
should always specify a non-NULL value in oldstate. A precisely analogous set of
statements applies for the oldtype argument of pthread_setcanceltype().
EXEMPLES
Consultez pthread_cancel(3).
VOIR AUSSI
pthread_cancel(3), pthread_cleanup_push(3), pthread_testcancel(3), pthreads(7)
COLOPHON
Cette page fait partie de la publication 5.13 du projet man-pages Linux. Une description
du projet et des instructions pour signaler des anomalies et la dernière version de cette
page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.
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> et Frédéric Hantrais
<fhantrais@gmail.com>
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⟩.