Provided by: manpages-fr-dev_4.13-4_all bug

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).

       ┌──────────────────────────┬──────────────────────┬─────────┐
       │InterfaceAttributValeur  │
       ├──────────────────────────┼──────────────────────┼─────────┤
       │pthread_setcancelstate(), │ Sécurité des threads │ MT-Safe │
       │pthread_setcanceltype()   │                      │         │
       ├──────────────────────────┼──────────────────────┼─────────┤
       │pthread_setcancelstate(), │ Async-cancel-safety  │ AC-Safe │
       │pthread_setcanceltype()   │                      │         │
       └──────────────────────────┴──────────────────────┴─────────┘

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.10 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 ⟨⟩.