Provided by: manpages-fr-dev_3.32d0.2p4-1_all bug

NOM

       pthread_attr_init,  pthread_attr_destroy - Initialiser et détruire un objet d'attributs de
       thread

SYNOPSIS

       #include <pthread.h>

       int pthread_attr_init(pthread_attr_t *attr);
       int pthread_attr_destroy(pthread_attr_t *attr);

       Compilez et effectuez l'édition des liens avec l'option -pthread.

DESCRIPTION

       La fonction pthread_attr_init() initialise l'objet d'attributs de thread pointé  par  attr
       avec des valeurs d'attributs par défaut. Après cet appel, les attributs individuels de cet
       objet peuvent être modifiés en utilisant diverses fonctions (listées dans la section  VOIR
       AUSSI),   et   l'objet   peut   alors   être  utilisé  dans  un  ou  plusieurs  appels  de
       pthread_create(3) pour créer des threads.

       Appeler pthread_attr_init() sur un objet d'attributs de thread qui a déjà  été  initialisé
       résulte en un comportement indéfini.

       Quand  un  objet  d'attributs  de thread n'est plus nécessaire, il devrait être détruit en
       appelant la fonction pthread_attr_destroy(). Détruire un objet d'attributs de  thread  n'a
       aucun effet sur les threads qui ont été créés en utilisant cet objet.

       Dès qu'un objet d'attributs de thread a été détruit, il peut être réinitialisé en appelant
       pthread_attr_init(). Toute autre utilisation d'un objet d'attributs de thread entraîne des
       résultats indéfinis.

VALEUR RENVOYÉE

       En  cas de réussite, ces fonctions renvoient 0 ; en cas d'erreur elles renvoient un numéro
       d'erreur non nul.

ERREURS

       POSIX.1-2001 documente  une  erreur  ENOMEM  pour  pthread_attr_init().  Sous  Linux,  ces
       fonctions  réussissent  toujours  (mais les applications portables et à l'épreuve du temps
       devraient néanmoins prendre en charge une possible valeur de retour).

CONFORMITÉ

       POSIX.1-2001.

NOTES

       Le type pthread_attr_t doit être traité comme opaque ; tout accès à l'objet en dehors  des
       fonctions pthreads n'est pas portable et peut produire des résultats indéfinis.

EXEMPLE

       Le  programme  ci-dessous  fait  un  appel  optionnel  à pthread_attr_init() et à d'autres
       fonctions similaires pour initialiser un objet d'attributs de thread  afin  de  l'utiliser
       pour   créer   un   thread   unique.   Une  fois  créé,  le  thread  utilise  la  fonction
       pthread_getattr_np(3) (une extension GNU non standard) pour  récupérer  les  attributs  de
       threads, et les afficher.

       Si  le  programme  est exécuté 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 créé  avec
       les attributs par défaut. En exécutant ce programme sur Linux/x86-32 avec l'implémentation
       NPTL, l'affichage sera :

           $ ulimit -s       # No stack imit ==> default stack size is 2MB
           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 passée 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 à pthread_create(3). En exécutant ce programme sur Linux/x86-32
       avec l'implémentation 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     /* Pour la déclaration de pthread_getattr_np() */
       #include <pthread.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <unistd.h>
       #include <errno.h>

       #define handle_error_en(en, msg) \
               do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)

       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)
               handle_error_en(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)
               handle_error_en(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)
               handle_error_en(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)
               handle_error_en(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)
               handle_error_en(s, "pthread_attr_getschedparam");
           printf("%sScheduling priority = %d\n", prefix, sp.sched_priority);

           s = pthread_attr_getguardsize(attr, &v);
           if (s != 0)
               handle_error_en(s, "pthread_attr_getguardsize");
           printf("%sGuard size          = %d bytes\n", prefix, v);

           s = pthread_attr_getstack(attr, &stkaddr, &v);
           if (s != 0)
               handle_error_en(s, "pthread_attr_getstack");
           printf("%sStack address       = %p\n", prefix, stkaddr);
           printf("%sStack size          = 0x%x 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)
               handle_error_en(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) {
               int stack_size;
               void *sp;

               attrp = &attr;

               s = pthread_attr_init(&attr);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_init");

               s = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_setdetachstate");

               s = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_setinheritsched");

               stack_size = strtoul(argv[1], NULL, 0);

               s = posix_memalign(&sp, sysconf(_SC_PAGESIZE), stack_size);
               if (s != 0)
                   handle_error_en(s, "posix_memalign");

               printf("posix_memalign() allocated at %p\n", sp);

               s = pthread_attr_setstack(&attr, sp, stack_size);
               if (s != 0)
                   handle_error_en(s, "pthread_attr_setstack");
           }

           s = pthread_create(&thr, attrp, &thread_start, NULL);
           if (s != 0)
               handle_error_en(s, "pthread_create");

           if (attrp != NULL) {
               s = pthread_attr_destroy(attrp);
               if (s != 0)
                   handle_error_en(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_setstack(3),   pthread_attr_setstackaddr(3),    pthread_attr_setstacksize(3),
       pthread_create(3), pthread_getattr_np(3), pthreads(7)

COLOPHON

       Cette  page  fait partie de la publication 3.32 du projet man-pages Linux. Une description
       du projet et des  instructions  pour  signaler  des  anomalies  peuvent  être  trouvées  à
       l'adresse <URL:http://www.kernel.org/doc/man-pages/>.

TRADUCTION

       Depuis    2010,    cette   traduction   est   maintenue   à   l'aide   de   l'outil   po4a
       <URL:http://po4a.alioth.debian.org/> par l'équipe de traduction  francophone  au  sein  du
       projet perkamon <URL:http://perkamon.alioth.debian.org/>.

       Denis Barbier (2010).

       Veuillez     signaler     toute     erreur     de     traduction     en     écrivant     à
       <debian-l10n-french@lists.debian.org>  ou  par  un  rapport  de  bogue   sur   le   paquet
       manpages-fr.

       Vous  pouvez  toujours  avoir  accès  à la version anglaise de ce document en utilisant la
       commande « man -L C <section> <page_de_man> ».