Provided by: manpages-fr-dev_4.21.0-2_all bug

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

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

STANDARDS

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

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