Discussion :

[lozxxx]

Bonjour, je suis débutant en programmation j aimerais savoir comment créer un programme père qui crée 2 fils, chaque fils crée deux fils, chaque processus écrit: je suis PID mon père est PPID. Merci d'avance.

voici mon code pour un programme père qui crée un fils:

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
int main (int argc, char * argv[]){ 
 
pid_t pid; 
 
if ((pid = fork())<0){ 
fprintf (stderr,"Il y a une erreur \n"); 
exit(EXIT_FAILURE); 
} 
else if (pid == 0){ 
printf("FILS: Je suis le fils, mon pid est: %d, celui de mon père: %d \n",getpid(), getppid()); 
exit(EXIT_SUCCESS); 
} 
else { 
printf("PÈRE: Je suis le père, mon pid est: %d, celui de mon fils: %d \n",getpid(), pid); 
int fin = wait(0); 
printf ("PÈRE: Mon fils se termine: son pid %d \n",fin); 
exit (EXIT_SUCCESS); 
} 
}

[Trademark]

Salut,

Il y a une balise CODE pour que le code soit formaté

Ensuite c'est pas très compliqué si tu as compris comment analyser le résultat du fork. Si tu dessines sur papier tu comprendras peut-être mieux.

Ce qui peut t'aider c'est de faire deux fonctions : une pour les fils et une pour les petits fils. Commence par celle du petit fils dans laquelle tu ne fais que afficher et puis tu quittes. Ensuite dans celle du fils tu fais une boucle de fork et tu appels la fonction petit fils. Tu attends les deux petits fils (2 wait()) et puis tu quittes. Puis dans le père tu fais pareil

Il y a aussi moyen de faire plus élégant avec une seule fonction (car tu répètes du code, tu vois bien que le père et ses fils font la même chose).

[lozxxx]

Merci beaucoup de ton aide j ai compris .

[Bktero]

N'ayant jamais utilisé fork(), je me suis dis que c'était le moment. J'ai donc essayé de faire le premier niveau (père + 2 fils) et je me pose une question sur l'utilisation de wait(). Voici mon 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 <sys/types.h> // pour pid_t
#include <unistd.h>  // pour fork(), getpid(), getppid()
#include <sys/wait.h>  // pour wait()
 
#define NBR_FILS 2
 
int main (void)
{
    pid_t fils[10];
    pid_t pere = getpid();
    int i=0;
 
    // Generation des fils
    for(i=0;i<NBR_FILS;i++)
    {
        fils[i] = fork();
        if(getpid() != pere)
            break;
        // Traitement lors du fork
        if(fils[i]<0)
        {
            fprintf(stderr,"Fork impossible");
            return -1;
        }
    }
 
    // Determination en fonction de la place genealogique
    pid_t pid = getpid();
    if (pid==pere)
    {
        fprintf(stdout, "Je suis le pere, monsieur %d\n", pere);
        // Attendre tous les fils
        for(i=0;i<NBR_FILS;wait(NULL),i++)
            ;
        fprintf(stdout, "Tous mes fils sont termines");
        return 1;
 
    } else if (pid!=pere)
    {
         fprintf(stdout,"Je suis le fils %d\t",getpid() );
         fprintf(stdout,"J'aime mon papa %d = %d\n", getppid(), pere );
         return 2;
    }
    return 0;
}

De ce que j'ai compris, wait() attend la fin d'un fils. Dans mon code, ma boucle ne fait met pas en attente de tous les fils, comme on pourrait faire un join avec les threads non ?

[lozxxx]

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
 
int main (int argc, char * argv[])
 
    {
        pid_t pid;
        int fils=0,i;
        printf("Je suis le pere id: %d\n",getpid());
        for (i=0;i<2;i++)
        {
            fils++;
            pid=fork();
            if (pid==0)
            {
                printf("Je suis le fils numero : %d pid:%d ppid: %d\n",fils,getpid(),getppid());
 
 
                int fils=0,i;
                for (i=0;i<2;i++)
                {
                    fils++;
                    pid=fork();
                    if (pid==0)
                    {
                        printf("Je suis le petit fils numero : %d pid: %d ppid: %d \n",fils,getpid(),getppid());
                        exit(EXIT_SUCCESS);
                    }
                }
                exit(EXIT_SUCCESS);
            }
        }
}

Voila mon code (corrigez moi si il est incorrecte) mais il reste le problème des wait() que je ne sais pas ou placer pour que chaque père attende ses fils respectifs. Ou dois-je les mettre ?

[Trademark]

A Bktero, il vaut mieux tester si tu es dans le père où le fils via la valeur de retour du fork et non via getpid(). Fork renvoie 0 si tu es dans le fils et le pid du fils si tu es dans le père. Sinon petite curiosité dans ton code, pourquoi utilises-tu fprintf(stdout,..); au lieu de printf ? Ça fait la même chose et printf est plus court.

Chaque processus n'a la responsabilité que de ses fils, donc il faut que le père attende ses fils et que les fils du père attendent leur fils à eux.

Le code ci-dessous est la correction, mais je te conseille d'essayer de placer les wait tout seul avant. Il faut évidemment comprendre où et quand le code de chaque partie est exécutée et c'est plus facile si tu fais des fonctions comme précisé plus haut. D'une autre part il faut que tu tests les retours de tes fork !

Compilé avec :

Code :

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

>gcc programme -std=c99

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
47
48
49
50
51
52
53
54
55
56
57
58
#include <sys/types.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
 
#define NB_FILS 2
 
void petit_fils()
{
  printf("Petit fils | PID %d | PPID %d \n", getpid(), getppid());
  exit(EXIT_SUCCESS);
}
 
void fils()
{
  printf("Fils | PID %d | PPID %d \n", getpid(), getppid());
 
  for(int i=0; i < NB_FILS; ++i)
  {
    pid_t pid = fork();
    if(pid == -1)
    {
      perror("fork");
      exit(EXIT_FAILURE);
    }
 
    if(pid == 0)
      petit_fils();
  }
  for(int i=0, status; i < NB_FILS; ++i)
    wait(&status);
 
  exit(EXIT_SUCCESS);
}
 
int main(int argc, char* argv[])
{
 
  for(int i=0; i < NB_FILS; ++i)
  {
    pid_t pid = fork();
    if(pid == -1)
    {
      perror("fork");
      exit(EXIT_FAILURE);
    }
 
    if(pid == 0)
      fils();
  } 
  printf("Pere | PID %d | PPID %d \n", getpid(), getppid());
 
  for(int i=0, status; i < NB_FILS; ++i)
    wait(&status);
 
  return EXIT_SUCCESS;
}

Si tu veux, tu peux essayer de faire le même programme avec un nombre de générations paramétrables. Ici ça serait 2. Si tu veux je pourrai te mettre la "correction" quand tu auras montré ce que tu as fait.