Valeurs de variable dans Fork() enfant

Question

J'ai déjà posé une question à propos de fork(), en voici une autre. Vu le code suivant:

#include <unistd.h> 
#include <stdio.h> 

int main() 
{ 
    pid_t pid1, pid2; 
    pid1 = fork(); 
    pid2 = fork(); 
    if (pid1 != 0 && pid2 != 0) 
     printf("A\n"); 
    if (pid1 != 0 || pid2 != 0) 
     printf("B\n"); 
    exit(0); 
} 

Après la deuxième fork(), quelles seraient les valeurs de pid1 & pid2?
Pour autant que compris, la première fourche définit pid1 > 0 et serait identique chez tous les enfants créés plus tard. Cependant, qu'arriverait-il à pid2 ??

Merci!

Answer 1

Je suis sur le point de tester pour vous, mais laissez-moi vous dire ce que j'espérais.

 
          /pid2=[child3 pid] { pid1 = child1;pid2 = child3;} 
     pid1=[child1 pid] fork() 
    /      \ 
    /      pid2=0    { pid1 = child1;pid2 = 0;} 
fork() 
     \       pid2=[child2 pid] { pid1 = 0;  pid2 = child2;} 
     \      /
     pid1=0   - fork() 
           \ 
           pid2=0    { pid1 = 0;  pid2 = 0;} 

EDIT testé. Code suit

#include <stdio.h> 
#include <unistd.h> 

int main() 
{ 
    pid_t pid1, pid2; 
    pid1 = fork(); 
    pid2 = fork(); 
    printf("PID %d: pid1=%d, pid2=%d\n",getpid() ,pid1, pid2); 
    exit(0); 
} 

sorties:

30805 PID: pid1 = 30806, pid2 = 30807
PID 30806: pid1 = 0, pid2 = 30808
PID 30807: pid1 = 30806, pid2 = 0
30808 PID: pid1 = 0, pid2 = 0

Answer 2

Fork prend le processus dans son état existant et le clone, vous avez donc maintenant deux copies identiques. Dans le processus d'origine, fork renvoie alors le PID du nouveau processus cloné. Dans le nouveau clone, fork renvoie 0.

Parent process: 
pid1 = PID of child 1 
pid2 = PID of child 3 

Child 1 
pid1 = 0 
pid2 = PID of child 2 

Child 2 
pid1 = 0 
pid2 = 0 

Child 3 
pid1 = PID of child 1 
pid2 = 0 

Answer 3

Lire la page man: http://linux.die.net/man/2/fork

pid1 sera donc 0 dans l'enfant du premier processus créé dans la première fourche, quelque chose d'autre dans le principal et son deuxième enfant. pid2 sera 0 dans le petit-enfant du premier processus et l'enfant créé dans la deuxième fourche dans le processus principal. Quelque chose d'autre partout ailleurs.

          /-[parent]pid1=?, pid2=? 
     /-[parent]pid1=?, pid2=uninit -> fork() 
fork()          \-[child2 of parent]pid1=?, pid2=0 
    \ 
     \            /-[child1 of parent]pid1=0,pid2=? 
     \[child1 of parent] pid1=0, pid2=uninit -> fork() 
                 \-[child of child] pid1=0, pid2=0 

Answer 4

Après la seconde fourche(), quelles seraient les valeurs de pid1 & pid2?

Cela dépend du processus dont vous parlez. Il y a quatre processus (y compris l'original) ici, la relation suivante entre eux:

A (original process) 
` - B (created by first fork in original process) 
| ` - C (created by second fork in B) 
` - D (created by second fork in original process) 

Ainsi, dans A, pid1 > 0 et pid2 > 0, car il a créé de nouveaux processus sur chaque fourche. En B, pid1 == 0 et pid2 > 0, car il a été créé par la première fourche et a créé un nouveau processus dans la deuxième fourche.

En C, pid1 == 0 et pid2 == 0, parce qu'elle hérite de la valeur de pid1 de son parent (B) et a été créée par la seconde fourche.

Dans D, pid1 > 0 et pid2 == 0, car il hérite de la valeur de pid1 de son parent (A) et a été créé par la deuxième branche.

Et bien sûr, n'oubliez pas que ce ne sont que les conditions initiales. Chaque processus a sa propre copie des valeurs, donc même si un processus hérite de la valeur initiale d'une variable de son parent, il peut toujours être modifié après la fourchette sans affecter la copie du parent.

Answer 5

Tout ce que vous avez à faire est de l'essayer:

#include <unistd.h> 
#include <stdio.h> 
int main (void) { 
    pid_t pid1 = -1, pid2 = -1; 
    pid1 = fork(); 
    pid2 = fork(); 
    printf ("%5d/%5d: %5d %5d\n", getpid(), getppid(), pid1, pid2); 
    sleep (5); // to prevent inheritance by init process on parent death 
    return 0; 
} 

et vous verrez:

PID/ PPID pid1 pid2 
---------- ---- ---- 
2507/ 2386: 2508 2509  first process 
2508/ 2507:  0 2510  first fork from 'first process' 
2509/ 2507: 2508  0  second fork from 'first process' 
2510/ 2508:  0  0  second fork from "first fork from 'first process'" 

En d'autres termes:

• le premier processus 2507 a pid1 et pid2 mis à ses deux enfants.
• le deuxième processus 2508 a pid1 de 0 puisqu'il était l'enfant dans cette fourche mais pid2 de 2510 parce que c'était le parent dans que fourche.
• le troisième processus 2509 hérite pid1 du premier processus (son parent) puisqu'il forge après qui a été défini. Son pid2 est 0 parce que c'est l'enfant dans la deuxième fourchette.
• le quatrième processus 2510 hérite pid1 du processus deuxième deuxième (son parent) car il forge après que cela a été défini. Son pid2 est également 0 parce que c'est l'enfant dans la deuxième fourchette.