Discussion :

[jedimind]

Bonjour,

une petite question au sujet des threads :
est ce qu'il existe une relation de parenté lorsque un thread crée un autre thread ? Si oui, est ce que je peux tuer le père et laisser le fils en vie ?

Je sais que cette relation existe entre un proc et les threads qu'il crée ... mais avec les threads ?

D'avance merci !

[hegros]

Bonsoir,

Je dirai que cela dépend.

Si le père est le thread primaire alors 'normalement' en le tuant tu tues aussi le processus et si tu tues le processus alors tout les threads attachés a ce dernier meurt.

Auquel cas je ne vois pas de problème. Normalement avec un petit programme et en faisant les modifications qu'il faut tu pourras te faire une idée du fonctionnement.

[jedimind]

Hegros,

j'avais effectivement codé un bout de programme pour vérifier ce comportement.
Il s'agit d'un programme super simple : un thread "père" est crée dans le main. Il crée un thread "fils" et se termine tout de suite. Le thread fils attend 5 secondes avant de se terminer.

Voilà le code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
#include <stdio.h>
#include <pthread.h>
#include <unistd.h>
 
static pthread_t lFatherThread;
static pthread_t lChildThread;
 
static void *ChildFunction()
{
  printf(">ChildFunction\n");
  sleep(5);
  printf("<ChildFunction\n");
  return ((void *) 0);
}
 
static void *FatherFunction()
{
  int rv;
  printf(">FatherFunction\n");
  rv = pthread_create(&lChildThread, (pthread_attr_t *)NULL, ChildFunction, (void *)NULL);
  if (rv < 0)
    {
      printf("2nd pthread_create failed : %d\n", rv);
      return 0;
    }
 
  printf("<FatherFunction\n");
  return ((void *) 0);
}
 
 
int main(void)
{
  int rv;
  printf(">main\n");
  rv = pthread_create(&lFatherThread, (pthread_attr_t *)NULL, FatherFunction, (void *)NULL);
  if (rv<0)
    {
      printf("main : first pthread_create failed : %d\n", rv);
      return 0; 
    }
  printf("<main\n");
 
  return 0;
}

La sortie est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
>main
>FatherFunction
<FatherFunction
>ChildFunction
<main
<ChildFunction

On voit donc que le thread "père" peut se terminer avant le "fils". Cela ne pose pas de problèmes. Par contre j'aurais pensé que le main se terminerait en dernier ...

[Médinoc]

Ben, si tu n'as pas le pthread_join avant la fin du main, non...

Par contre, le programme ne se termine plus à la fin du main: Le main est encapsulé par le noyau de la librairie pthread...


Sous Windows, c'est un peu plus vicieux à comprendre, mais ça marche de la même manière, pourvu que le main se termine par un ExitThread() et non un return.