pthread_setcancelstate(3) Library Functions Manual pthread_setcancelstate(3) NOM pthread_setcancelstate, pthread_setcanceltype -- Definir l'etat et le type d'annulation BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #include int pthread_setcancelstate(int state, int *oldstate); int pthread_setcanceltype(int type, int *oldtype); DESCRIPTION La fonction pthread_setcancelstate() definit l'etat d'annulation du thread appelant a la valeur indiquee par state. L'ancien etat d'annulation du thread est renvoye dans le tampon pointe par oldstate. L'argument state doit avoir une des valeurs suivantes : PTHREAD_CANCEL_ENABLE Le thread peut etre annule. C'est l'etat d'annulation par defaut pour tous les nouveaux threads, y compris le thread initial. Le type d'annulation du thread determine quand un thread annulable repondra a une requete d'annulation. PTHREAD_CANCEL_DISABLE Le thread n'est pas annulable. Si une requete d'annulation arrive, elle est bloquee jusqu'a ce que l'annulation soit activee. La fonction pthread_setcanceltype() definit le type d'annulation du thread appelant a la valeur indiquee par type. L'ancien type d'annulation du thread est renvoye dans le tampon pointe par oldtype. L'argument type doit avoir une des valeurs suivantes : PTHREAD_CANCEL_DEFERRED Une requete d'annulation est retarde jusqu'a ce que le thread appelle une fonction qui est un point d'annulation (consultez pthreads(7)). C'est le type d'annulation par defaut pour tous les nouveaux threads, y compris le thread initial. Meme avec une annulation retardee, un point d'annulation dans un gestionnaire de signal asynchrone peut encore etre pris en compte et l'effet est similaire a s'il s'agissait d'une annulation asynchrone. PTHREAD_CANCEL_ASYNCHRONOUS Le thread peut etre annule a tout moment. Typiquement, il sera annule des reception de la requete d'annulation, mais ce n'est pas garanti par le systeme. Les operations set/get effectuees par ces fonctions sont atomiques, eu egard aux autres threads du processus qui appellent la meme fonction. VALEUR RENVOYEE En cas de succes, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un code d'erreur non nul. ERREURS pthread_setcancelstate() peut echouer avec l'erreur suivante : EINVAL Valeur invalide pour state. pthread_setcanceltype() peut echouer avec l'erreur suivante : EINVAL Valeur invalide pour type. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +-------------------------------+----------------------------+---------+ |Interface | Attribut | Valeur | +-------------------------------+----------------------------+---------+ |pthread_setcancelstate(), | Securite des threads | MT-Safe | |pthread_setcanceltype() | | | +-------------------------------+----------------------------+---------+ |pthread_setcancelstate(), | Securite signaux async | AC-Safe | |pthread_setcanceltype() | | | +-------------------------------+----------------------------+---------+ STANDARDS POSIX.1-2008. HISTORIQUE glibc 2.0 POSIX.1-2001. NOTES For details of what happens when a thread is canceled, see pthread_cancel(3). Desactiver brievement l'annulation peut etre pratique si un thread effectue une action critique qui ne doit pas etre interrompue par une requete d'annulation. Mais attention de ne pas desactiver l'annulation sur de longues periodes, ou autour d'operations qui peuvent ploquer pendant un long moment, car cela empecherait le thread de repondre aux requetes d'annulation. Annulation asynchrone Le type d'annulation est rarement mis a PTHREAD_CANCEL_ASYNCHRONOUS. Comme le thread pourrait etre annule n'importe quand, il ne pourrait pas reserver de ressources (par exemple en allouant de la memoire avec malloc(3)) de maniere sure, acquerir des verrous exclusifs (mutex), des semaphores, des verrous, etc. Reserver des ressources n'est pas sur, car l'application n'a aucun moyen de connaitre l'etat de ces ressources quand le thread est annule ; en d'autres termes, l'annulation arrive-t-elle avant que les ressources n'aient ete reservees, pendant qu'elles sont reservees, ou apres qu'elles ont ete liberees ? De plus, certaines structures de donnees internes (par exemple la liste chainee des blocs libres geree par la famille de fonctions malloc(3)) pourraient se retrouver dans un etat incoherent si l'annulation se passe au milieu d'un appel de fonction. En consequence de quoi les gestionnaires de nettoyage perdent toute utilite. Les fonctions qui peuvent sans risque etre annulees de maniere asynchrone sont appelees des fonctions async-cancel-safe. POSIX.1-2001 et POSIX.1-2008 necessitent seulement que pthread_cancel(3), pthread_setcancelstate() et pthread_setcanceltype() soient async-cancel-safe. En general, les autres fonctions de la bibliotheque ne peuvent pas etre appelees de maniere sure depuis un thread annulable immediatement. Une des rares circonstances dans lesquelles une annulation immediate est utile est pour l'annulation d'un thread qui est dans une boucle qui ne fait que des calculs. Notes sur la portabilite Les implementations de Linux autorisent l'argument oldstate de pthread_setcancelstate() a etre NULL, auquel cas l'information au sujet de l'etat anterieur d'annulation n'est pas renvoyee a l'appelant. Beaucoup d'autres implementations autorisent aussi un argument oldstat NULL, mais POSIX.1 ne specifie pas ce point, si bien que les applications portables devraient toujours donner une valeur non NULL a oldstate. Le meme type de raisonnement s'applique a 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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais et Jean- Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 pthread_setcancelstate(3)