.\" -*- coding: UTF-8 -*-
.\" Copyright (c) 2005 by Michael Kerrisk <mtk.manpages@gmail.com>
.\"
.\" %%%LICENSE_START(VERBATIM)
.\" Permission is granted to make and distribute verbatim copies of this
.\" manual provided the copyright notice and this permission notice are
.\" preserved on all copies.
.\"
.\" Permission is granted to copy and distribute modified versions of this
.\" manual under the conditions for verbatim copying, provided that the
.\" entire resulting derived work is distributed under the terms of a
.\" permission notice identical to this one.
.\"
.\" Since the Linux kernel and libraries are constantly changing, this
.\" manual page may be incorrect or out-of-date.  The author(s) assume no
.\" responsibility for errors or omissions, or for damages resulting from
.\" the use of the information contained herein.  The author(s) may not
.\" have taken the same level of care in the production of this manual,
.\" which is licensed free of charge, as they might when working
.\" professionally.
.\"
.\" Formatted or processed versions of this manual, if unaccompanied by
.\" the source, must acknowledge the copyright and authors of this work.
.\" %%%LICENSE_END
.\"
.\"*******************************************************************
.\"
.\" This file was generated with po4a. Translate the source file.
.\"
.\"*******************************************************************
.TH PTHREADS 7 "21 décembre 2020" Linux "Manuel du programmeur Linux"
.SH NOM
pthreads \- Threads POSIX
.SH DESCRIPTION
POSIX.1 décrit une série d'interfaces (fonctions et fichiers d'en\(hytê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).
.PP
POSIX.1 requiert aussi que les threads partagent une série d'autres
attributs (ces attributs sont par processus, plutôt que par thread)\ :
.IP \- 3
identifiant de processus (PID)
.IP \- 3
identifiant de processus père (PPID)
.IP \- 3
identifiant de groupe de processus (PGID) et identifiant de session (SID)
.IP \- 3
terminal de contrôle
.IP \- 3
identifiants d'utilisateur et de groupe
.IP \- 3
descripteurs de fichier ouverts
.IP \- 3
verrouillages d'enregistrements (consultez \fBfcntl\fP(2))
.IP \- 3
gestion de signaux
.IP \- 3
masque de création de fichier (\fBumask\fP(2))
.IP \- 3
répertoire de travail (\fBchdir\fP(2)) et répertoire racine (\fBchroot\fP(2))
.IP \- 3
temporisations d'intervalle (\fBsetitimer\fP(2)) et temporisations POSIX
(\fBtimer_create\fP(2))
.IP \- 3
valeur de politesse (\fBsetpriority\fP(2))
.IP \- 3
limites de ressources (\fBsetrlimit\fP(2))
.IP \- 3
mesures de consommation de temps CPU (\fBtimes\fP(2)) et de ressources
(\fBgetrusage\fP(2))
.PP
En plus de la pile, POSIX.1 indique que plusieurs autres attributs sont
distincts pour chaque thread, dont les suivants\ :
.IP \- 3
identifiant de thread (le type de donnée \fIpthread_t\fP)
.IP \- 3
masque de signaux (\fBpthread_sigmask\fP(3))
.IP \- 3
la variable \fIerrno\fP
.IP \- 3
pile spécifique de signal (\fBsigaltstack\fP(2))
.IP \- 3
politique et priorité d'ordonnancement temps\-réel (\fBsched\fP(7))
.PP
Les caractéristiques spécifiques à Linux suivantes sont également distinctes
pour chaque thread\ :
.IP \- 3
capacités (consultez \fBcapabilities\fP(7))
.IP \- 3
affinité CPU (\fBsched_setaffinity\fP(2))
.SS "Valeurs de retour des fonctions pthreads"
Most pthreads functions return 0 on success, and an error number on
failure.  The error numbers that can be returned have the same meaning as
the error numbers returned in \fIerrno\fP by conventional system calls and C
library functions.  Note that the pthreads functions do not set \fIerrno\fP.
For each of the pthreads functions that can return an error, POSIX.1\-2001
specifies that the function can never fail with the error \fBEINTR\fP.
.SS "Identifiants de thread"
Each of the threads in a process has a unique thread identifier (stored in
the type \fIpthread_t\fP).  This identifier is returned to the caller of
\fBpthread_create\fP(3), and a thread can obtain its own thread identifier
using \fBpthread_self\fP(3).
.PP
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.)
.PP
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."
.SS "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.
.PP
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\ :
.PP
.in +4n
.EX
asctime()
basename()
catgets()
crypt()
ctermid() if passed a non\-NULL argument
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 only (function removed in POSIX.1\-2008)]
encrypt()
endgrent()
endpwent()
endutxent()
fcvt() [POSIX.1\-2001 only (function removed in POSIX.1\-2008)]
ftw()
gcvt() [POSIX.1\-2001 only (function removed in POSIX.1\-2008)]
getc_unlocked()
getchar_unlocked()
getdate()
getenv()
getgrent()
getgrgid()
getgrnam()
gethostbyaddr() [POSIX.1\-2001 only (function removed in
                 POSIX.1\-2008)]
gethostbyname() [POSIX.1\-2001 only (function removed in
                 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() [Added in POSIX.1\-2008]
strtok()
system() [Added in POSIX.1\-2008]
tmpnam() if passed a non\-NULL argument
ttyname()
unsetenv()
wcrtomb() if its final argument is NULL
wcsrtombs() if its final argument is NULL
wcstombs()
wctomb()
.EE
.in
.SS "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
\fBpthread_setcancelstate\fP(3)).
.PP
POSIX.1\-2001 et POSIX.1\-2008 exigent que seules les fonctions suivantes
soient pour annulations sûres asynchrones\ :
.PP
.in +4n
.EX
pthread_cancel()
pthread_setcancelstate()
pthread_setcanceltype()
.EE
.in
.SS "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.
.PP
POSIX.1\-2001 et/ou POSIX.1\-2008 exigent que les fonctions suivantes soient
des points d'annulation\ :
.PP
.\" FIXME
.\" Document the list of all functions that are cancellation points in glibc
.in +4n
.EX
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()
.EE
.in
.PP
POSIX.1\-2001 et/ou POSIX.1\-2008 indiquent que les fonctions suivantes
peuvent être des points d'annulation\ :
.PP
.in +4n
.EX
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() [POSIX.1\-2001 only (function removed in
                 POSIX.1\-2008)]
gethostbyname() [POSIX.1\-2001 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() [POSIX.1\-2001 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()
.EE
.in
.PP
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).
.PP
.\" So, scanning "cancellation point" comments in the glibc 2.8 header
.\" files, it looks as though at least the following nonstandard
.\" functions are cancellation points:
.\" endnetgrent
.\" endspent
.\" epoll_pwait
.\" epoll_wait
.\" fcloseall
.\" fdopendir
.\" fflush_unlocked
.\" fgetc_unlocked
.\" fgetgrent
.\" fgetgrent_r
.\" fgetpwent
.\" fgetpwent_r
.\" fgets_unlocked
.\" fgetspent
.\" fgetspent_r
.\" fgetwc_unlocked
.\" fgetws_unlocked
.\" fputc_unlocked
.\" fputs_unlocked
.\" fputwc_unlocked
.\" fputws_unlocked
.\" fread_unlocked
.\" fwrite_unlocked
.\" gai_suspend
.\" getaddrinfo_a
.\" getdate_r
.\" getgrent_r
.\" getgrouplist
.\" gethostbyaddr_r
.\" gethostbyname2
.\" gethostbyname2_r
.\" gethostbyname_r
.\" gethostent_r
.\" getnetbyaddr_r
.\" getnetbyname_r
.\" getnetent_r
.\" getnetgrent
.\" getnetgrent_r
.\" getprotobyname_r
.\" getprotobynumber_r
.\" getprotoent_r
.\" getpw
.\" getpwent_r
.\" getservbyname_r
.\" getservbyport_r
.\" getservent_r
.\" getspent
.\" getspent_r
.\" getspnam
.\" getspnam_r
.\" getutmp
.\" getutmpx
.\" getw
.\" getwc_unlocked
.\" getwchar_unlocked
.\" initgroups
.\" innetgr
.\" mkostemp
.\" mkostemp64
.\" mkstemp64
.\" ppoll
.\" pthread_timedjoin_np
.\" putgrent
.\" putpwent
.\" putspent
.\" putw
.\" putwc_unlocked
.\" putwchar_unlocked
.\" rcmd
.\" rcmd_af
.\" rexec
.\" rexec_af
.\" rresvport
.\" rresvport_af
.\" ruserok
.\" ruserok_af
.\" setnetgrent
.\" setspent
.\" sgetspent
.\" sgetspent_r
.\" updwtmpx
.\" utmpxname
.\" vfscanf
.\" vfwscanf
.\" vscanf
.\" vsyslog
.\" vwscanf
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.
.SS "Compiler sous Linux"
Sous Linux, les programmes utilisant l'API pthreads doivent être compilés
avec \fIcc \-pthread\fP.
.SS "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\ :
.TP 
\fBLinuxThreads\fP
Il s'agit de l'implémentation des Pthreads originelle. Depuis la glibc\ 2.4,
cette implémentation n'est plus prise en charge.
.TP 
\fBNPTL\fP (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.
.PP
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 \fBclone\fP(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 \fBfutex\fP(2) de Linux.
.SS LinuxThreads
Les fonctionnalités importantes de cette implémentation sont les suivantes\ :
.IP \- 3
En plus du thread principal (initial) et des threads créés par le programme
avec \fBpthread_create\fP(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.
.IP \- 3
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
\fBsignal\fP(7)). Sous les noyaux plus anciens, LinuxThreads utilise \fBSIGUSR1\fP
et \fBSIGUSR2\fP. Les applications doivent éviter d'utiliser les signaux
utilisés par l'implémentation.
.IP \- 3
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 \fBps\fP(1).
.PP
L'implémentation LinuxThreads s'écarte de la spécification POSIX.1 par
plusieurs aspects, dont les suivants\ :
.IP \- 3
Les appels à \fBgetpid\fP(2) renvoient une valeur distincte dans chaque thread.
.IP \- 3
Les appels à \fBgetppid\fP(2) dans les threads autres que le thread principal
renvoient l'identifiant de processus du thread de gestion\ ; \fBgetppid\fP(2)
dans ces threads devrait renvoyer la même valeur que dans le thread
principal.
.IP \- 3
When one thread creates a new child process using \fBfork\fP(2), any thread
should be able to \fBwait\fP(2)  on the child.  However, the implementation
allows only the thread that created the child to \fBwait\fP(2)  on it.
.IP \- 3
Lorsqu'un thread appelle \fBexecve\fP(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é \fBexecve\fP(2)\ : il devrait avoir le même PID que
le thread principal.
.IP \- 3
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 \fBseteuid\fP(2) et consorts.
.IP \- 3
Les threads ne partagent pas l'identifiant de session et de groupe de
processus.
.IP \- 3
Les threads ne partagent pas les verrouillages d'enregistrements créés avec
\fBfcntl\fP(2).
.IP \- 3
L'information renvoyée par \fBtimes\fP(2) et \fBgetrusage\fP(2) est par thread au
lieu d'être par processus.
.IP \- 3
Les threads ne partagent pas les valeurs «\ undo\ » de sémaphores (voir
\fBsemop\fP(2)).
.IP \- 3
Les threads ne partagent pas les temporisations d'intervalles.
.IP \- 3
Les threads ne partagent pas leur valeur de politesse.
.IP \- 3
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 \fBkill\fP(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.
.IP \- 3
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.)
.SS 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.
.PP
NPTL makes internal use of the first two real\-time signals; these signals
cannot be used in applications.  See \fBnptl\fP(7)  for further details.
.PP
NPTL a encore au moins une non conformité à POSIX.1\ :
.IP \- 3
.\" FIXME . bug report filed for NPTL nice nonconformance
.\" http://bugzilla.kernel.org/show_bug.cgi?id=6258
.\" Sep 08: there is a patch by Denys Vlasenko to address this
.\" "make setpriority POSIX compliant; introduce PRIO_THREAD extension"
.\" Monitor this to see if it makes it into mainline.
Les threads ne partagent pas leur valeur de politesse.
.PP
Certaines non conformités n'apparaissent qu'avec des noyaux plus anciens\ :
.IP \- 3
L'information renvoyée par \fBtimes\fP(2) et \fBgetrusage\fP(2) est par thread au
lieu d'être globale au processus (corrigé dans le noyau\ 2.6.9).
.IP \- 3
Les threads ne partagent pas les limites de ressources (corrigé dans le
noyau\ 2.6.10).
.IP \- 3
Les threads ne partagent pas les temporisations d'intervalles (corrigé dans
le noyau\ 2.6.12).
.IP \- 3
Seul le thread principal est autorisé à démarrer une nouvelle session avec
\fBsetsid\fP(2) (corrigé dans le noyau\ 2.6.16).
.IP \- 3
Seul le thread principal est autorisé à rendre le processus leader de son
groupe de processus avec \fBsetpgid\fP(2) (corrigé dans le noyau\ 2.6.16).
.IP \- 3
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).
.PP
Veuillez noter les points suivants à propos de l'implémentation NPTL\ :
.IP \- 3
Si la limite souple de taille de pile (voir dans \fBsetrlimit\fP(2) la
description de \fBRLIMIT_STACK\fP) est différente de \fIunlimited\fP, 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 \fIulimit \-s\fP du shell (\fIlimit
stacksize\fP dans csh).
.SS "Déterminer l'implémentation des threads utilisée"
Depuis glibc\ 2.3.2, la commande \fBgetconf\fP(1) peut être utilisée pour
déterminer l'implémentation de threads du système, par exemple\ :
.PP
.in +4n
.EX
bash$ getconf GNU_LIBPTHREAD_VERSION
NPTL 2.3.4
.EE
.in
.PP
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\ :
.PP
.in +4n
.EX
bash$ $( ldd /bin/ls | grep libc.so | awk \(aq{print $3}\(aq ) | \e
                egrep \-i \(aqthreads|nptl\(aq
        Native POSIX Threads Library by Ulrich Drepper et al
.EE
.in
.SS "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.\fIx\fP), la variable d'environnement \fBLD_ASSUME_KERNEL\fP 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\ :
.PP
.in +4n
.EX
bash$ $( LD_ASSUME_KERNEL=2.2.5 ldd /bin/ls | grep libc.so | \e
                awk \(aq{print $3}\(aq ) | egrep \-i \(aqthreads|nptl\(aq
        linuxthreads\-0.10 by Xavier Leroy
.EE
.in
.SH "VOIR AUSSI"
.ad l
.nh
\fBclone\fP(2), \fBfork\fP(2), \fBfutex\fP(2), \fBgettid\fP(2), \fBproc\fP(5),
\fBattributes\fP(7), \fBfutex\fP(7), \fBnptl\fP(7), \fBsigevent\fP(7), \fBsignal\fP(7)
.PP
Various Pthreads manual pages, for example: \fBpthread_atfork\fP(3),
\fBpthread_attr_init\fP(3), \fBpthread_cancel\fP(3), \fBpthread_cleanup_push\fP(3),
\fBpthread_cond_signal\fP(3), \fBpthread_cond_wait\fP(3), \fBpthread_create\fP(3),
\fBpthread_detach\fP(3), \fBpthread_equal\fP(3), \fBpthread_exit\fP(3),
\fBpthread_key_create\fP(3), \fBpthread_kill\fP(3), \fBpthread_mutex_lock\fP(3),
\fBpthread_mutex_unlock\fP(3), \fBpthread_mutexattr_destroy\fP(3),
\fBpthread_mutexattr_init\fP(3), \fBpthread_once\fP(3), \fBpthread_spin_init\fP(3),
\fBpthread_spin_lock\fP(3), \fBpthread_rwlockattr_setkind_np\fP(3),
\fBpthread_setcancelstate\fP(3), \fBpthread_setcanceltype\fP(3),
\fBpthread_setspecific\fP(3), \fBpthread_sigmask\fP(3), \fBpthread_sigqueue\fP(3),
and \fBpthread_testcancel\fP(3)
.SH COLOPHON
Cette page fait partie de la publication\ 5.10 du projet \fIman\-pages\fP
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/.

.SH 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
.UR https://www.gnu.org/licenses/gpl-3.0.html
GNU General Public License version 3
.UE
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 à
.MT
debian-l10n-french@lists.debian.org
.ME .