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

Question

J'ai une question concernant l'implémentation des threads dans Linux.

Linux ne dispose pas d'un support explicite pour les threads. Dans l'espace utilisateur, nous pouvons utiliser une bibliothèque de threads (comme NPTL) pour créer des threads. Or, si nous utilisons NPTL, elle prend en charge la correspondance 1:1.

Le noyau utilisera l'option clone() pour mettre en œuvre les threads.

Supposons que j'aie créé 4 fils de discussion. Cela signifierait que :

• Il y aura 4 task_struct .
• A l'intérieur de la task_struct Il est prévu de partager les ressources en fonction des arguments en faveur du clonage. (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND) .

J'ai maintenant la requête suivante :

1. Les 4 fils auront-ils le même PID ? Si quelqu'un peut expliquer comment les PID sont partagés.
2. Comment les différentes discussions sont-elles identifiées ? Existe-t-il un concept de TID (thread ID) ?

Answer 1

Les quatre fils auront le même PID, mais seulement lorsqu'ils seront vus depuis le site ci-dessus. Ce qu'il faut faire usted (en tant qu'utilisateur) appelle un PID n'est pas ce que le noyau (vu d'en bas) appelle un PID.

Dans le cadre de la noyau, chaque thread a son propre identifiant, appelé PID, bien qu'il serait peut-être plus logique de l'appeler TID, ou thread ID, et il a également un TGID (thread group ID) qui est le PID du premier thread qui a été créé lors de la création du processus.

Lorsqu'un nouveau processus est créé, il apparaît comme un fil dont le PID et le TGID sont tous deux le même numéro (actuellement inutilisé).

Lorsqu'un fil de discussion en démarre un autre fil, ce nouveau thread obtient son propre PID (afin que le planificateur puisse le programmer indépendamment) mais il hérite du TGID du thread d'origine.

De cette manière, le noyau peut programmer des threads indépendamment du processus auquel ils appartiennent, tandis que les processus (ID de groupes de threads) vous sont signalés.

La hiérarchie suivante des fils peut être utile (a) :

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

Vous pouvez constater que le démarrage d'un nouveau processus (à gauche) vous donne un nouveau PID y un nouveau TGID (les deux ayant la même valeur). Le démarrage d'un nouveau fil (à droite) vous donne un nouveau PID tout en conservant le même TGID que le fil qui l'a démarré.

---

(a) Tremblez d'admiration à mes impressionnantes compétences graphiques :-)

Answer 2

Les threads sont identifiés à l'aide de PID et de TGID (Thread group id). Ils savent également quel thread est le parent de qui, de sorte qu'un processus partage son PID avec tous les threads qu'il démarre. Les identifiants 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 devraient avoir le même PID. Le noyau lui-même s'occupe de l'ordonnancement des threads, mais c'est la bibliothèque qui gère les threads (qu'ils puissent tourner ou non, selon l'utilisation que vous faites des méthodes de jointure et d'attente).

Note : Ceci est tiré de mes souvenirs du noyau 2.6.36. Mon travail dans les versions actuelles du noyau porte sur la couche E/S, je ne sais donc pas si cela a changé depuis.

Answer 3

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