pthreads

PTHREADS(7)                Manuel du programmeur Linux               PTHREADS(7)



NOM
       pthreads - Threads POSIX

DESCRIPTION
       POSIX.1 décrit une série d'interfaces (fonctions et fichiers d'en‐têtes)
       pour la programmation multithread, couramment appelée threads POSIX, ou
       pthreads. Un unique processus peut contenir plusieurs threads, qui
       exécutent tous le même programme. Ces threads partagent la même mémoire
       globale (segments de données et tas), mais chaque thread a sa propre pile
       (variables automatiques).

       POSIX.1 requiert aussi que les threads partagent une série d'autres
       attributs (ces attributs sont par processus, plutôt que par thread) :

       -  identifiant de processus (PID)

       -  identifiant de processus père (PPID)

       -  identifiant de groupe de processus (PGID) et identifiant de session
          (SID)

       -  terminal de contrôle

       -  identifiants d'utilisateur et de groupe

       -  descripteurs de fichier ouverts

       -  verrouillages d'enregistrements (consultez fcntl(2))

       -  gestion de signaux

       -  masque de création de fichier (umask(2))

       -  répertoire de travail (chdir(2)) et répertoire racine (chroot(2))

       -  temporisations d'intervalle (setitimer(2)) et temporisations POSIX
          (timer_create(2))

       -  valeur de politesse (setpriority(2))

       -  limites de ressources (setrlimit(2))

       -  mesures de consommation de temps CPU (times(2)) et de ressources
          (getrusage(2))

       En plus de la pile, POSIX.1 indique que plusieurs autres attributs sont
       distincts pour chaque thread, dont les suivants :

       -  identifiant de thread (le type de donnée pthread_t)

       -  masque de signaux (pthread_sigmask(3))

       -  la variable errno

       -  pile spécifique de signal (sigaltstack(2))

       -  politique et priorité d'ordonnancement temps-réel (sched(7))

       Les caractéristiques spécifiques à Linux suivantes sont également
       distinctes pour chaque thread :

       -  capacités (consultez capabilities(7))

       -  affinité CPU (sched_setaffinity(2))

   Valeurs de retour des fonctions pthreads
       Most pthreads functions return 0 on success, and an error number on
       failure.  Note that the pthreads functions do not set errno.  For each of
       the pthreads functions that can return an error, POSIX.1-2001 specifies
       that the function can never fail with the error EINTR.

   Identifiants de thread
       Each of the threads in a process has a unique thread identifier (stored
       in the type pthread_t).  This identifier is returned to the caller of
       pthread_create(3), and a thread can obtain its own thread identifier
       using pthread_self(3).

       Thread IDs are guaranteed to be unique only within a process.  (In all
       pthreads functions that accept a thread ID as an argument, that ID by
       definition refers to a thread in the same process as the caller.)

       The system may reuse a thread ID after a terminated thread has been
       joined, or a detached thread has terminated.  POSIX says: "If an
       application attempts to use a thread ID whose lifetime has ended, the
       behavior is undefined."

   Fonctions sûres du point de vue des threads
       Une fonction sûre du point de vue des threads est une fonction qui peut
       être appelée en toute sûreté (c'est-à-dire qu'elle renverra le même
       résultat d'où qu'elle soit appelée) par plusieurs threads en même temps.

       POSIX.1-2001 et POSIX.1-2008 exigent que toutes les fonctions indiquées
       dans la norme soient sûres du point de vue des threads, excepté les
       fonctions suivantes :

           asctime()
           basename()
           catgets()
           crypt()
           ctermid() avec un paramètre non NULL
           ctime()
           dbm_clearerr()
           dbm_close()
           dbm_delete()
           dbm_error()
           dbm_fetch()
           dbm_firstkey()
           dbm_nextkey()
           dbm_open()
           dbm_store()
           dirname()
           dlerror()
           drand48()
           ecvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           encrypt()
           endgrent()
           endpwent()
           endutxent()
           fcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           ftw()
           gcvt() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           getc_unlocked()
           getchar_unlocked()
           getdate()
           getenv()
           getgrent()
           getgrgid()
           getgrnam()
           gethostbyaddr() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           gethostbyname() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           gethostent()
           getlogin()
           getnetbyaddr()
           getnetbyname()
           getnetent()
           getopt()
           getprotobyname()
           getprotobynumber()
           getprotoent()
           getpwent()
           getpwnam()
           getpwuid()
           getservbyname()
           getservbyport()
           getservent()
           getutxent()
           getutxid()
           getutxline()
           gmtime()
           hcreate()
           hdestroy()
           hsearch()
           inet_ntoa()
           l64a()
           lgamma()
           lgammaf()
           lgammal()
           localeconv()
           localtime()
           lrand48()
           mrand48()
           nftw()
           nl_langinfo()
           ptsname()
           putc_unlocked()
           putchar_unlocked()
           putenv()
           pututxline()
           rand()
           readdir()
           setenv()
           setgrent()
           setkey()
           setpwent()
           setutxent()
           strerror()
           strsignal() [Ajoutée dans POSIX.1-2008]
           strtok()
           system() [Ajoutée dans POSIX.1-2008]
           tmpnam() avec un paramètre non NULL
           ttyname()
           unsetenv()
           wcrtomb() si son dernier paramètre est NULL
           wcsrtombs() si son dernier paramètre est NULL
           wcstombs()
           wctomb()

   Fonctions pour annulations sûres asynchrones
       Une fonction pour annulations sûres asynchrones peut être appelée sans
       risque dans une application où l'état d'annulation est activé (consultez
       pthread_setcancelstate(3)).

       POSIX.1-2001 et POSIX.1-2008 exigent que seules les fonctions suivantes
       soient pour annulations sûres asynchrones :

           pthread_cancel()
           pthread_setcancelstate()
           pthread_setcanceltype()

   Points d'annulation
       POSIX.1 spécifie que certaines fonctions doivent, et certaines autres
       fonctions peuvent, être des points d'annulation. Si un thread est
       annulable, que son type d'annulation est retardé (« deferred ») et qu'une
       demande d'annulation est en cours pour ce thread, alors le thread est
       annulé quand il appelle une fonction qui est un point d'annulation.

       POSIX.1-2001 et/ou POSIX.1-2008 exigent que les fonctions suivantes
       soient des points d'annulation :

           accept()
           aio_suspend()
           clock_nanosleep()
           close()
           connect()
           creat()
           fcntl() F_SETLKW
           fdatasync()
           fsync()
           getmsg()
           getpmsg()
           lockf() F_LOCK
           mq_receive()
           mq_send()
           mq_timedreceive()
           mq_timedsend()
           msgrcv()
           msgsnd()
           msync()
           nanosleep()
           open()
           openat() [Ajoutée dans POSIX.1-2008]
           pause()
           poll()
           pread()
           pselect()
           pthread_cond_timedwait()
           pthread_cond_wait()
           pthread_join()
           pthread_testcancel()
           putmsg()
           putpmsg()
           pwrite()
           read()
           readv()
           recv()
           recvfrom()
           recvmsg()
           select()
           sem_timedwait()
           sem_wait()
           send()
           sendmsg()
           sendto()
           sigpause() [POSIX.1-2001 uniquement (dans la liste des fonctions pouvant être un point d'annulation dans POSIX.1-2008)]
           sigsuspend()
           sigtimedwait()
           sigwait()
           sigwaitinfo()
           sleep()
           system()
           tcdrain()
           usleep() [POSIX.1-2001 uniquement (fonction supprimée dans POSIX.1-2008)]
           wait()
           waitid()
           waitpid()
           write()
           writev()

       POSIX.1-2001 et/ou POSIX.1-2008 indiquent que les fonctions suivantes
       peuvent être des points d'annulation :

           access()
           asctime()
           asctime_r()
           catclose()
           catgets()
           catopen()
           chmod() [Added in POSIX.1-2008]
           chown() [Added in POSIX.1-2008]
           closedir()
           closelog()
           ctermid()
           ctime()
           ctime_r()
           dbm_close()
           dbm_delete()
           dbm_fetch()
           dbm_nextkey()
           dbm_open()
           dbm_store()
           dlclose()
           dlopen()
           dprintf() [Added in POSIX.1-2008]
           endgrent()
           endhostent()
           endnetent()
           endprotoent()
           endpwent()
           endservent()
           endutxent()
           faccessat() [Added in POSIX.1-2008]
           fchmod() [Added in POSIX.1-2008]
           fchmodat() [Added in POSIX.1-2008]
           fchown() [Added in POSIX.1-2008]
           fchownat() [Added in POSIX.1-2008]
           fclose()
           fcntl() (for any value of cmd argument)
           fflush()
           fgetc()
           fgetpos()
           fgets()
           fgetwc()
           fgetws()
           fmtmsg()
           fopen()
           fpathconf()
           fprintf()
           fputc()
           fputs()
           fputwc()
           fputws()
           fread()
           freopen()
           fscanf()
           fseek()
           fseeko()
           fsetpos()
           fstat()
           fstatat() [Added in POSIX.1-2008]
           ftell()
           ftello()
           ftw()
           futimens() [Added in POSIX.1-2008]
           fwprintf()
           fwrite()
           fwscanf()
           getaddrinfo()
           getc()
           getc_unlocked()
           getchar()
           getchar_unlocked()
           getcwd()
           getdate()
           getdelim() [Added in POSIX.1-2008]
           getgrent()
           getgrgid()
           getgrgid_r()
           getgrnam()
           getgrnam_r()
           gethostbyaddr() [SUSv3 only (function removed in POSIX.1-2008)]
           gethostbyname() [SUSv3 only (function removed in POSIX.1-2008)]
           gethostent()
           gethostid()
           gethostname()
           getline() [Added in POSIX.1-2008]
           getlogin()
           getlogin_r()
           getnameinfo()
           getnetbyaddr()
           getnetbyname()
           getnetent()
           getopt() (if opterr is nonzero)
           getprotobyname()
           getprotobynumber()
           getprotoent()
           getpwent()
           getpwnam()
           getpwnam_r()
           getpwuid()
           getpwuid_r()
           gets()
           getservbyname()
           getservbyport()
           getservent()
           getutxent()
           getutxid()
           getutxline()
           getwc()
           getwchar()
           getwd() [SUSv3 only (function removed in POSIX.1-2008)]
           glob()
           iconv_close()
           iconv_open()
           ioctl()
           link()
           linkat() [Added in POSIX.1-2008]
           lio_listio() [Added in POSIX.1-2008]
           localtime()
           localtime_r()
           lockf() [Added in POSIX.1-2008]
           lseek()
           lstat()
           mkdir() [Added in POSIX.1-2008]
           mkdirat() [Added in POSIX.1-2008]
           mkdtemp() [Added in POSIX.1-2008]
           mkfifo() [Added in POSIX.1-2008]
           mkfifoat() [Added in POSIX.1-2008]
           mknod() [Added in POSIX.1-2008]
           mknodat() [Added in POSIX.1-2008]
           mkstemp()
           mktime()
           nftw()
           opendir()
           openlog()
           pathconf()
           pclose()
           perror()
           popen()
           posix_fadvise()
           posix_fallocate()
           posix_madvise()
           posix_openpt()
           posix_spawn()
           posix_spawnp()
           posix_trace_clear()
           posix_trace_close()
           posix_trace_create()
           posix_trace_create_withlog()
           posix_trace_eventtypelist_getnext_id()
           posix_trace_eventtypelist_rewind()
           posix_trace_flush()
           posix_trace_get_attr()
           posix_trace_get_filter()
           posix_trace_get_status()
           posix_trace_getnext_event()
           posix_trace_open()
           posix_trace_rewind()
           posix_trace_set_filter()
           posix_trace_shutdown()
           posix_trace_timedgetnext_event()
           posix_typed_mem_open()
           printf()
           psiginfo() [Added in POSIX.1-2008]
           psignal() [Added in POSIX.1-2008]
           pthread_rwlock_rdlock()
           pthread_rwlock_timedrdlock()
           pthread_rwlock_timedwrlock()
           pthread_rwlock_wrlock()
           putc()
           putc_unlocked()
           putchar()
           putchar_unlocked()
           puts()
           pututxline()
           putwc()
           putwchar()
           readdir()
           readdir_r()
           readlink() [Added in POSIX.1-2008]
           readlinkat() [Added in POSIX.1-2008]
           remove()
           rename()
           renameat() [Added in POSIX.1-2008]
           rewind()
           rewinddir()
           scandir() [Added in POSIX.1-2008]
           scanf()
           seekdir()
           semop()
           setgrent()
           sethostent()
           setnetent()
           setprotoent()
           setpwent()
           setservent()
           setutxent()
           sigpause() [Added in POSIX.1-2008]
           stat()
           strerror()
           strerror_r()
           strftime()
           symlink()
           symlinkat() [Added in POSIX.1-2008]
           sync()
           syslog()
           tmpfile()
           tmpnam()
           ttyname()
           ttyname_r()
           tzset()
           ungetc()
           ungetwc()
           unlink()
           unlinkat() [Added in POSIX.1-2008]
           utime() [Added in POSIX.1-2008]
           utimensat() [Added in POSIX.1-2008]
           utimes() [Added in POSIX.1-2008]
           vdprintf() [Added in POSIX.1-2008]
           vfprintf()
           vfwprintf()
           vprintf()
           vwprintf()
           wcsftime()
           wordexp()
           wprintf()
           wscanf()

       Une implémentation peut également indiquer d'autres fonctions non
       spécifiées dans la norme comme étant des points d'annulation. En
       particulier, une implémentation marquera probablement toute fonction non
       standard qui peut bloquer comme étant un point d'annulation (ceci inclus
       la plupart des fonctions qui peuvent toucher des fichiers).

       It should be noted that even if an application is not using asynchronous
       cancellation, that calling a function from the above list from an
       asynchronous signal handler may cause the equivalent of asynchronous
       cancellation.  The underlying user code may not expect asynchronous
       cancellation and the state of the user data may become inconsistent.
       Therefore signals should be used with caution when entering a region of
       deferred cancellation.

   Compiler sous Linux
       Sous Linux, les programmes utilisant l'API pthreads doivent être compilés
       avec cc -pthread.

   Implémentations des threads POSIX sous Linux
       Deux implémentations différentes des threads ont été fournies par la
       bibliothèque C de GNU sous Linux :

       LinuxThreads
              Il s'agit de l'implémentation des Pthreads originelle. Depuis la
              glibc 2.4, cette implémentation n'est plus prise en charge.

       NPTL (Native POSIX Threads Library)
              Il s'agit de l'implémentation moderne des Pthreads. Par rapport à
              LinuxThreads, NPTL se conforme mieux aux exigences de la norme
              POSIX.1, et une meilleure performance lors de la création d'un
              grand nombre de threads. NPTL est disponible depuis la
              glibc 2.3.2, et nécessite des fonctionnalités présentes dans le
              noyau Linux 2.6.

       Ces deux implémentation sont dit de type 1:1, ce qui veut dire que chaque
       thread correspond à une entité d'ordonnancement du noyau. Les deux
       implémentations utilisent l'appel système clone(2) de Linux. Dans NPTL,
       les primitives de synchronisation de threads (mutexes, jonction de
       thread, etc.) sont implémentées avec l'appel système futex(2) de Linux.

   LinuxThreads
       Les fonctionnalités importantes de cette implémentation sont les
       suivantes :

       -  En plus du thread principal (initial) et des threads créés par le
          programme avec pthread_create(3), l'implémentation crée un thread de
          gestion. Ce thread s'occupe de la création et de la terminaison des
          threads. Des problèmes peuvent survenir si ce thread est tué de façon
          imprévue.

       -  Les signaux sont utilisés en interne par l'implémentation. Sous
          Linux 2.2 et suivants, les trois premiers signaux temps-réel sont
          utilisés (voir aussi signal(7)). Sous les noyaux plus anciens,
          LinuxThreads utilise SIGUSR1 et SIGUSR2. Les applications doivent
          éviter d'utiliser les signaux utilisés par l'implémentation.

       -  Les threads ne partagent pas leur identifiant de processus. (En fait,
          les threads LinuxThreads sont implémentés comme des processus
          partageant plus d'informations qu'à l'habitude, mais pas leur
          identifiant de processus.) Les threads LinuxThreads (y compris le
          thread de gestion) sont visibles comme des processus différents avec
          ps(1).

       L'implémentation LinuxThreads s'écarte de la spécification POSIX.1 par
       plusieurs aspects, dont les suivants :

       -  Les appels à getpid(2) renvoient une valeur distincte dans chaque
          thread.

       -  Les appels à getppid(2) dans les threads autres que le thread
          principal renvoient l'identifiant de processus du thread de gestion ;
          getppid(2) dans ces threads devrait renvoyer la même valeur que dans
          le thread principal.

       -  When one thread creates a new child process using fork(2), any thread
          should be able to wait(2)  on the child.  However, the implementation
          allows only the thread that created the child to wait(2)  on it.

       -  Lorsqu'un thread appelle execve(2), tous les autres threads sont
          terminés (comme le prescrit POSIX.1). Cependant, le processus
          résultant a le même PID que le thread ayant appelé execve(2) : il
          devrait avoir le même PID que le thread principal.

       -  Les threads ne partagent pas leurs identifiants d'utilisateur et de
          groupe. Ceci peut causer des complications pour les programmes setuid
          et provoquer des erreurs dans les fonctions pthreads si une
          application change d'identifiant avec seteuid(2) et consorts.

       -  Les threads ne partagent pas l'identifiant de session et de groupe de
          processus.

       -  Les threads ne partagent pas les verrouillages d'enregistrements créés
          avec fcntl(2).

       -  L'information renvoyée par times(2) et getrusage(2) est par thread au
          lieu d'être par processus.

       -  Les threads ne partagent pas les valeurs « undo » de sémaphores (voir
          semop(2)).

       -  Les threads ne partagent pas les temporisations d'intervalles.

       -  Les threads ne partagent pas leur valeur de politesse.

       -  POSIX.1 distingue les notions de signal envoyé au processus dans son
          ensemble, et de signal envoyé à un thread individuellement. Selon
          POSIX.1, un signal envoyé au processus (par exemple avec kill(2)) sera
          géré par un thread choisi arbitrairement au sein du processus.
          LinuxThreads ne permet pas d'envoyer un signal au processus, mais
          seulement à un thread spécifique.

       -  Les threads ont des paramètres de pile spécifique de signal distincts.
          Cependant, les paramètres de pile spécifique d'un nouveau thread sont
          copiés à partir du thread qui l'a créé, ce qui veut dire que les
          threads partagent initialement une même pile spécifique de signaux.
          (Un nouveau thread devrait démarrer sans pile spécifique de signaux.
          Si deux threads gèrent un signal sur leur pile spécifique au même
          moment, des échecs imprévisibles du programme risquent de se
          produire.)

   NPTL
       With NPTL, all of the threads in a process are placed in the same thread
       group; all members of a thread group share the same PID.  NPTL does not
       employ a manager thread.

       NPTL makes internal use of the first two real-time signals; these signals
       cannot be used in applications.  See nptl(7)  for further details.

       NPTL a encore au moins une non conformité à POSIX.1 :

       -  Les threads ne partagent pas leur valeur de politesse.

       Certaines non conformités n'apparaissent qu'avec des noyaux plus
       anciens :

       -  L'information renvoyée par times(2) et getrusage(2) est par thread au
          lieu d'être globale au processus (corrigé dans le noyau 2.6.9).

       -  Les threads ne partagent pas les limites de ressources (corrigé dans
          le noyau 2.6.10).

       -  Les threads ne partagent pas les temporisations d'intervalles (corrigé
          dans le noyau 2.6.12).

       -  Seul le thread principal est autorisé à démarrer une nouvelle session
          avec setsid(2) (corrigé dans le noyau 2.6.16).

       -  Seul le thread principal est autorisé à rendre le processus leader de
          son groupe de processus avec setpgid(2) (corrigé dans le
          noyau 2.6.16).

       -  Les threads ont des paramètres de pile spécifique de signaux
          distincts. Cependant, les paramètres de pile spécifique d'un nouveau
          thread sont copiés sur ceux du thread qui l'a créé, et les threads
          partagent donc initialement leur pile spécifique de signaux (corrigé
          dans le noyau 2.6.16).

       Veuillez noter les points suivants à propos de l'implémentation NPTL :

       -  Si la limite souple de taille de pile (voir dans setrlimit(2) la
          description de RLIMIT_STACK) est différente de unlimited, cette valeur
          détermine la taille de pile par défaut pour les nouveaux threads. Pour
          avoir un effet, cette limite doit être définie avant le démarrage du
          programme, par exemple en utilisant la commande ulimit -s du shell
          (limit stacksize dans csh).

   Déterminer l'implémentation des threads utilisée
       Depuis glibc 2.3.2, la commande getconf(1) peut être utilisée pour
       déterminer l'implémentation de threads du système, par exemple :

           bash$ getconf GNU_LIBPTHREAD_VERSION
           NPTL 2.3.4

       Avec des versions plus anciennes de la glibc, une commande comme la
       suivante devrait être suffisante pour déterminer l'implémentation de
       threads par défaut :

           bash$ $( ldd /bin/ls | grep libc.so | awk '{print $3}' ) | \
                           egrep -i 'threads|nptl'
                   Native POSIX Threads Library by Ulrich Drepper et al

   Choisir l'implémentation des threads : LD_ASSUME_KERNEL
       Sur les systèmes avec une glibc fournissant à la fois LinuxThreads et
       NPTL (i.e. glibc 2.3.x), la variable d'environnement LD_ASSUME_KERNEL
       peut être utilisée pour écraser le choix par défaut d'implémentation de
       threads fait par l'éditeur de liens dynamique. Cette variable indique à
       l'éditeur de liens dynamique qu'il doit faire comme s'il était exécuté
       avec une version particulière du noyau. En indiquant une version du noyau
       ne fournissant pas les fonctionnalités nécessitées par NPTL, on peut
       forcer l'utilisation de LinuxThreads. (La raison la plus probable pour
       cela est d'exécuter une application (boguée) qui dépend d'un comportement
       de LinuxThreads non conforme à la spécification.) Par exemple :

           bash$ $( LD_ASSUME_KERNEL=2.2.5 ldd /bin/ls | grep libc.so | \
                           awk '{print $3}' ) | egrep -i 'threads|nptl'
                   linuxthreads-0.10 by Xavier Leroy

VOIR AUSSI
       clone(2), fork(2), futex(2), gettid(2), proc(5), attributes(7), futex(7),
       nptl(7), sigevent(7), signal(7)

       Various Pthreads manual pages, for example: pthread_atfork(3),
       pthread_attr_init(3), pthread_cancel(3), pthread_cleanup_push(3),
       pthread_cond_signal(3), pthread_cond_wait(3), pthread_create(3),
       pthread_detach(3), pthread_equal(3), pthread_exit(3),
       pthread_key_create(3), pthread_kill(3), pthread_mutex_lock(3),
       pthread_mutex_unlock(3), pthread_mutexattr_destroy(3),
       pthread_mutexattr_init(3), pthread_once(3), pthread_spin_init(3),
       pthread_spin_lock(3), pthread_rwlockattr_setkind_np(3),
       pthread_setcancelstate(3), pthread_setcanceltype(3),
       pthread_setspecific(3), pthread_sigmask(3), pthread_sigqueue(3), and
       pthread_testcancel(3)

COLOPHON
       Cette page fait partie de la publication 5.08 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 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                             13 août 2020                       PTHREADS(7)