Si les threads partagent le même PID, comment peuvent-ils être identifiés?

J'ai une question liée à l'implémentation des threads sous Linux.

Linux n'a pas de support de thread explicite. Dans l'espace utilisateur, nous pouvons utiliser une bibliothèque de threads (comme NPTL) pour créer des threads. Maintenant, si nous utilisons NPTL, il prend en charge le mappage 1: 1.

Le noyau utilisera la clone()fonction pour implémenter les threads.

Supposons que j'ai créé 4 threads. Cela signifierait alors que:

• Il y en aura 4 task_struct.
• À l'intérieur du task_struct, il y aura fourniture de ressources de partage selon les arguments à cloner (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND).

Maintenant, j'ai la requête suivante:

1. Les 4 threads auront-ils le même PID? Si quelqu'un peut préciser, comment les PID sont partagés.
2. Comment les différents threads sont-ils identifiés? y a-t-il un concept TID (thread ID)?

Les quatre threads auront le même PID mais uniquement lorsqu'ils sont vus d'en haut. Ce que vous (en tant qu'utilisateur) appelez un PID n'est pas ce que le noyau (en regardant d'en bas) appelle un PID.

Dans le noyau, chaque thread a son propre ID, appelé PID (bien qu'il serait peut-être plus logique d'appeler cela un TID, ou ID de thread) et ils ont également un TGID (ID de groupe de threads) qui est le PID du thread qui a commencé tout le processus.

De manière simpliste, lorsqu'un nouveau processus est créé, il apparaît comme un thread où le PID et le TGID sont le même (nouveau) numéro.

Lorsqu'un thread démarre un autre thread, ce thread démarré obtient son propre PID (afin que le planificateur puisse le planifier indépendamment) mais il hérite du TGID du thread d'origine.

De cette façon, le noyau peut planifier avec plaisir les threads indépendamment du processus auquel ils appartiennent, tandis que les processus (ID de groupe de threads) vous sont signalés.

La hiérarchie suivante des fils peut aider ^(a) :

                      USER VIEW
 <-- PID 43 --> <----------------- PID 42 ----------------->
                     +---------+
                     | process |
                    _| pid=42  |_
                  _/ | tgid=42 | \_ (new thread) _
       _ (fork) _/   +---------+                  \
      /                                        +---------+
+---------+                                    | process |
| process |                                    | pid=44  |
| pid=43  |                                    | tgid=42 |
| tgid=43 |                                    +---------+
+---------+
 <-- PID 43 --> <--------- PID 42 --------> <--- PID 44 --->
                     KERNEL VIEW

Vous pouvez voir que le démarrage d'un nouveau processus (à gauche) vous donne un nouveau PID et un nouveau TGID (tous deux définis sur la même valeur), tandis que le démarrage d'un nouveau thread (à droite) vous donne un nouveau PID tout en conservant le même TGID comme thread qui l'a démarré.

^(a) Trembler d'émerveillement devant mes impressionnantes compétences graphiques :-)

Les threads sont identifiés à l'aide des PID et TGID (Thread group id). Ils savent également quel thread est un parent de qui donc essentiellement un processus partage son PID avec tous les threads qu'il démarre. Les ID de threads sont généralement gérés par la bibliothèque de threads elle-même (comme pthread, etc ...). Si les 4 threads sont démarrés, ils doivent avoir le même PID. Le noyau lui-même gérera la planification des threads et autres, mais la bibliothèque est celle qui va gérer les threads (qu'ils puissent s'exécuter ou non en fonction de votre utilisation des méthodes de thread join et wait).

Remarque: Ceci provient de mes souvenirs du noyau 2.6.36. Mon travail dans les versions actuelles du noyau est dans la couche I / O, donc je ne sais pas si cela a changé depuis.

Linux fournit à l' fork()appel système la fonctionnalité traditionnelle de duplication d'un processus. Linux offre également la possibilité de créer des threads à l'aide de l' clone()appel système. Cependant, linux ne fait pas la distinction entre les processus et les threads.