pthread_attr_init(3) Library Functions Manual pthread_attr_init(3) NOM pthread_attr_init, pthread_attr_destroy -- Initialiser et detruire un objet d'attributs de thread BIBLIOTHEQUE Bibliotheque de threads POSIX (libpthread, -lpthread) SYNOPSIS #include int pthread_attr_init(pthread_attr_t *attr); int pthread_attr_destroy(pthread_attr_t *attr); DESCRIPTION La fonction pthread_attr_init() initialise l'objet d'attributs de thread pointe par attr avec des valeurs d'attributs par defaut. Apres cet appel, les attributs individuels de cet objet peuvent etre modifies en utilisant diverses fonctions (listees dans la section VOIR AUSSI), et l'objet peut alors etre utilise dans un ou plusieurs appels de pthread_create(3) pour creer des threads. Appeler pthread_attr_init() sur un objet d'attributs de thread qui a deja ete initialise resulte en un comportement indefini. Quand un objet d'attributs de thread n'est plus necessaire, il devrait etre detruit en appelant la fonction pthread_attr_destroy(). Detruire un objet d'attributs de thread n'a aucun effet sur les threads qui ont ete crees en utilisant cet objet. Des qu'un objet d'attributs de thread a ete detruit, il peut etre reinitialise en appelant pthread_attr_init(). Toute autre utilisation d'un objet d'attributs de thread entraine des resultats indefinis. VALEUR RENVOYEE En cas de succes, ces fonctions renvoient 0 ; en cas d'erreur, elles renvoient un code d'erreur non nul. ERREURS POSIX.1 documente une erreur ENOMEM pour pthread_attr_init(). Sous Linux, ces fonctions reussissent toujours (mais les applications portables et a l'epreuve du temps devraient neanmoins prendre en charge une possible valeur de retour). ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +---------------------------------+--------------------------+---------+ |Interface | Attribut | Valeur | +---------------------------------+--------------------------+---------+ |pthread_attr_init(), | Securite des threads | MT-Safe | |pthread_attr_destroy() | | | +---------------------------------+--------------------------+---------+ STANDARDS POSIX.1-2008. HISTORIQUE POSIX.1-2001. NOTES Le type pthread_attr_t doit etre traite comme opaque ; tout acces a l'objet en dehors des fonctions pthreads n'est pas portable et peut produire des resultats indefinis. EXEMPLES Le programme ci-dessous fait un appel optionnel a pthread_attr_init() et a d'autres fonctions similaires pour initialiser un objet d'attributs de thread afin de l'utiliser pour creer un thread unique. Une fois cree, le thread utilise la fonction pthread_getattr_np(3) (une extension GNU non standard) pour recuperer les attributs de thread et les afficher. Si le programme est execute sans argument sur la ligne de commande, alors il passe NULL comme valeur de l'argument attr de pthread_create(3), si bien que le thread est cree avec les attributs par defaut. En executant ce programme sur Linux/x86-32 avec l'implementation NPTL, l'affichage sera : $ ulimit -s # No stack limit ==> default stack size is 2 MB unlimited $ ./a.out Thread attributes: Detach state = PTHREAD_CREATE_JOINABLE Scope = PTHREAD_SCOPE_SYSTEM Inherit scheduler = PTHREAD_INHERIT_SCHED Scheduling policy = SCHED_OTHER Scheduling priority = 0 Guard size = 4096 bytes Stack address = 0x40196000 Stack size = 0x201000 bytes Quand une taille de pile est passee sur la ligne de commande, le programme initialise un objet d'attributs de thread, modifie divers attributs de cet objet, et passe un pointeur sur cet objet dans l'appel a pthread_create(3). En executant ce programme sur Linux/x86-32 avec l'implementation NPTL, l'affichage sera : $ ./a.out 0x3000000 posix_memalign() allocated at 0x40197000 Thread attributes: Detach state = PTHREAD_CREATE_DETACHED Scope = PTHREAD_SCOPE_SYSTEM Inherit scheduler = PTHREAD_EXPLICIT_SCHED Scheduling policy = SCHED_OTHER Scheduling priority = 0 Guard size = 0 bytes Stack address = 0x40197000 Stack size = 0x3000000 bytes Source du programme #define _GNU_SOURCE /* To get pthread_getattr_np() declaration */ #include #include #include #include #include #include static void display_pthread_attr(pthread_attr_t *attr, char *prefix) { int s, i; size_t v; void *stkaddr; struct sched_param sp; s = pthread_attr_getdetachstate(attr, &i); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getdetachstate"); printf("%sDetach state = %s\n", prefix, (i == PTHREAD_CREATE_DETACHED) ? "PTHREAD_CREATE_DETACHED" : (i == PTHREAD_CREATE_JOINABLE) ? "PTHREAD_CREATE_JOINABLE" : "???"); s = pthread_attr_getscope(attr, &i); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getscope"); printf("%sScope = %s\n", prefix, (i == PTHREAD_SCOPE_SYSTEM) ? "PTHREAD_SCOPE_SYSTEM" : (i == PTHREAD_SCOPE_PROCESS) ? "PTHREAD_SCOPE_PROCESS" : "???"); s = pthread_attr_getinheritsched(attr, &i); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getinheritsched"); printf("%sInherit scheduler = %s\n", prefix, (i == PTHREAD_INHERIT_SCHED) ? "PTHREAD_INHERIT_SCHED" : (i == PTHREAD_EXPLICIT_SCHED) ? "PTHREAD_EXPLICIT_SCHED" : "???"); s = pthread_attr_getschedpolicy(attr, &i); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getschedpolicy"); printf("%sScheduling policy = %s\n", prefix, (i == SCHED_OTHER) ? "SCHED_OTHER" : (i == SCHED_FIFO) ? "SCHED_FIFO" : (i == SCHED_RR) ? "SCHED_RR" : "???"); s = pthread_attr_getschedparam(attr, &sp); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getschedparam"); printf("%sScheduling priority = %d\n", prefix, sp.sched_priority); s = pthread_attr_getguardsize(attr, &v); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getguardsize"); printf("%sGuard size = %zu bytes\n", prefix, v); s = pthread_attr_getstack(attr, &stkaddr, &v); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_getstack"); printf("%sStack address = %p\n", prefix, stkaddr); printf("%sStack size = %#zx bytes\n", prefix, v); } static void * thread_start(void *arg) { int s; pthread_attr_t gattr; /* pthread_getattr_np() is a non-standard GNU extension that retrieves the attributes of the thread specified in its first argument. */ s = pthread_getattr_np(pthread_self(), &gattr); if (s != 0) errc(EXIT_FAILURE, s, "pthread_getattr_np"); printf("Thread attributes:\n"); display_pthread_attr(&gattr, "\t"); exit(EXIT_SUCCESS); /* Terminate all threads */ } int main(int argc, char *argv[]) { pthread_t thr; pthread_attr_t attr; pthread_attr_t *attrp; /* NULL or &attr */ int s; attrp = NULL; /* If a command-line argument was supplied, use it to set the stack-size attribute and set a few other thread attributes, and set attrp pointing to thread attributes object. */ if (argc > 1) { size_t stack_size; void *sp; attrp = &attr; s = pthread_attr_init(&attr); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_init"); s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_setdetachstate"); s = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_setinheritsched"); stack_size = strtoul(argv[1], NULL, 0); s = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stack_size); if (s != 0) errc(EXIT_FAILURE, s, "posix_memalign"); printf("posix_memalign() allocated at %p\n", sp); s = pthread_attr_setstack(&attr, sp, stack_size); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_setstack"); } s = pthread_create(&thr, attrp, &thread_start, NULL); if (s != 0) errc(EXIT_FAILURE, s, "pthread_create"); if (attrp != NULL) { s = pthread_attr_destroy(attrp); if (s != 0) errc(EXIT_FAILURE, s, "pthread_attr_destroy"); } pause(); /* Terminates when other thread calls exit() */ } VOIR AUSSI pthread_attr_setaffinity_np(3), pthread_attr_setdetachstate(3), pthread_attr_setguardsize(3), pthread_attr_setinheritsched(3), pthread_attr_setschedparam(3), pthread_attr_setschedpolicy(3), pthread_attr_setscope(3), pthread_attr_setsigmask_np(3), pthread_attr_setstack(3), pthread_attr_setstackaddr(3), pthread_attr_setstacksize(3), pthread_create(3), pthread_getattr_np(3), pthread_setattr_default_np(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.9.1 15 juin 2024 pthread_attr_init(3)