pthread_setcancelstate

PTHREAD_SETCANCELSTATE(3)  Manuel du programmeur Linux PTHREAD_SETCANCELSTATE(3)



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(), │ 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 ⟨⟩.




Linux                              9 juin 2020         PTHREAD_SETCANCELSTATE(3)