multithreading - sistemas - python thread library

Si los hilos comparten el mismo PID, ¿cómo se pueden identificar?

Question

Tengo una consulta relacionada con la implementación de hilos en Linux.

Linux no tiene un soporte de hilos explícito. En el espacio de usuario, podríamos usar una biblioteca de hilos (como NPTL) para crear hilos. Ahora si usamos NPTL, admite mapeo 1: 1.

El núcleo usará la función clone() para implementar subprocesos.

Supongamos que he creado 4 hilos. Entonces significaría que:

• Habrá 4 task_struct .
• Dentro de task_struct , habrá provisión de recursos compartidos según los argumentos para clonar (CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND) .

Ahora tengo la siguiente consulta:

1. ¿Los 4 hilos tendrán el mismo PID? Si alguien puede dar más detalles, cómo se comparten los PID.
2. ¿Cómo se identifican los diferentes hilos? ¿Hay algún concepto TID (ID de hilo)?

Answer 1

Linux proporciona la llamada al sistema fork() con la funcionalidad tradicional de duplicar un proceso. Linux también proporciona la capacidad de crear subprocesos utilizando la llamada al sistema clone() Sin embargo, Linux no distingue entre procesos y subprocesos.

Answer 2

Los cuatro hilos tendrán el mismo PID pero solo cuando se ven desde arriba. Lo que usted (como usuario) llama un PID no es lo que el kernel (mirando desde abajo) llama a un PID.

En el kernel, cada subproceso tiene su propio ID, llamado PID (aunque posiblemente tenga más sentido llamarlo TID o ID de subproceso) y también tienen un TGID (Id. De grupo de subprocesos) que es el PID del subproceso eso comenzó todo el proceso.

Simplísticamente, cuando se crea un nuevo proceso , aparece como un subproceso donde tanto el PID como el TGID son el mismo número (nuevo).

Cuando un subproceso inicia otro subproceso, el subproceso iniciado obtiene su propio PID (por lo que el planificador puede programarlo de forma independiente) pero hereda el TGID del subproceso original.

De esta forma, el kernel puede planificar con éxito los hilos independientemente del proceso al que pertenecen, mientras que los procesos (IDs del grupo de hilos) se le informan.

La siguiente jerarquía de hilos puede ayudar ^(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

Puede ver que comenzar un nuevo proceso (a la izquierda) le proporciona un nuevo PID y un nuevo TGID (ambos configurados con el mismo valor), mientras que al iniciar un nuevo hilo (a la derecha) se obtiene un nuevo PID mientras se mantiene el mismo TGID como el hilo que lo inició.

^(a) Temblo de asombro ante mis impresionantes habilidades gráficas :-)

Answer 3

Los subprocesos se identifican utilizando PID y TGID (identificación del grupo de subprocesos). También saben de qué hilo es padre de quién, esencialmente, un proceso comparte su PID con cualquier hilo que comience. Las ID de subprocesos generalmente son administradas por la biblioteca de subprocesos (como pthread, etc ...). Si los 4 hilos se inician, deberían tener el mismo PID. El kernel mismo manejará la programación de hilos y demás, pero la biblioteca será la que administre los hilos (ya sea que se ejecuten o no dependiendo del uso de los métodos de unión de hilos y de espera).

Nota: Esto es de mi recuerdo de Kernel 2.6.36. Mi trabajo en las versiones actuales del núcleo está en la capa de E / S, así que no sé si eso ha cambiado desde entonces.