L'appel système Fork est utilisé pour créer un nouveau processus sous Linux et les systèmes Unix, appelé le processus enfant , qui s'exécute en même temps que le processus qui effectue l'appel fork() (processus parent). Une fois qu'un nouveau processus enfant est créé, les deux processus exécuteront l'instruction suivante suivant l'appel système fork().
Le processus enfant utilise le même PC (compteur de programme), les mêmes registres CPU et les mêmes fichiers ouverts que ceux utilisés dans le processus parent. Il ne prend aucun paramètre et renvoie une valeur entière.
Vous trouverez ci-dessous différentes valeurs renvoyées par fork().
- Valeur négative : La création d'un processus enfant a échoué.
- Zéro : Retour au processus enfant nouvellement créé.
- Valeur positive : Renvoyé au parent ou à l'appelant. La valeur contient l'ID de processus du processus enfant nouvellement créé.
Note: fork() est une fonction basée sur les threads, pour obtenir le résultat correct, exécutez le programme sur un système local.
Veuillez noter que les programmes ci-dessus ne se compilent pas dans un environnement Windows.
Exemple de fork() en C
C
films123 à
#include> #include> #include> int> main()> {> > >// make two process which run same> >// program after this instruction> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >printf>(>'Hello world!, process_id(pid) = %d
'>,getpid());> >return> 0;> }> |
>
>Sortir
Hello world!, process_id(pid) = 31 Hello world!, process_id(pid) = 32>
Exemple 2 : Calculez le nombre de fois où bonjour est imprimé.
C
#include> #include> #include> int> main()> {> >fork();> >fork();> >fork();> >printf>(>'hello
'>);> >return> 0;> }> |
>
>Sortir
hello hello hello hello hello hello hello hello>
Explication
Le nombre de fois où « bonjour » est imprimé est égal au nombre de processus créés. Nombre total de processus = 2n, où n est le nombre d'appels système fork. Donc ici n = 3, 23= 8 Mettons quelques noms d'étiquettes pour les trois lignes :
fork (); // Line 1 fork (); // Line 2 fork (); // Line 3 L1 // There will be 1 child process / // created by line 1. L2 L2 // There will be 2 child processes / / // created by line 2 L3 L3 L3 L3 // There will be 4 child processes // created by line 3>
Il y a donc un total de huit processus (nouveaux processus enfants et un processus original). Si nous voulons représenter la relation entre les processus sous forme d'une hiérarchie arborescente, ce serait le suivant : Le processus principal : P0 Processus créés par le 1er fork : P1 Processus créés par le 2ème fork : P2, P3 Processus créés par le 3ème fork : P4, P5, P6, P7
P0 / | P1 P4 P2 / P3 P6 P5 / P7>
Exemple 3 : Prédire la sortie du programme suivant.
C
#include> #include> #include> #include> void> forkexample()> {> >pid_t p;> >p = fork();> >if>(p<0)> >{> >perror>(>'fork fail'>);> >exit>(1);> >}> >// child process because return value zero> >else> if> ( p == 0)> >printf>(>'Hello from Child!
'>);> > >// parent process because return value non-zero.> >else> >printf>(>'Hello from Parent!
'>);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Sortir
Hello from Parent! Hello from Child!>
Note: Dans le code ci-dessus, un processus enfant est créé. fork() renvoie 0 dans le processus enfant et un entier positif dans le processus parent. Ici, deux sorties sont possibles car le processus parent et le processus enfant s'exécutent simultanément. Nous ne savons donc pas si le système d’exploitation donnera d’abord le contrôle au processus parent ou au processus enfant.
Le processus parent et le processus enfant exécutent le même programme, mais cela ne signifie pas qu'ils sont identiques. Le système d'exploitation alloue des données et des états différents pour ces deux processus, et le flux de contrôle de ces processus peut être différent. Voir l'exemple suivant :
Exemple 4 : Prédire la sortie du programme suivant.
C
télécharger une vidéo YouTube avec VLC
#include> #include> #include> #include> > void> forkexample()> {> >int> x = 1;> >pid_t p = fork();> >if>(p<0){> >perror>(>'fork fail'>);> >exit>(1);> >}> >else> if> (p == 0)> >printf>(>'Child has x = %d
'>, ++x);> >else> >printf>(>'Parent has x = %d
'>, --x);> }> int> main()> {> >forkexample();> >return> 0;> }> |
>
>Sortir
Parent has x = 0 Child has x = 2>
ou
Sortir
Child has x = 2 Parent has x = 0>
Ici, le changement de variable globale dans un processus n'affecte pas deux autres processus car les données/états des deux processus sont différents. De plus, le parent et l'enfant fonctionnent simultanément, donc deux sorties sont possibles.
fork() contre exec()
L’appel système fork crée un nouveau processus. Le nouveau processus créé par fork() est une copie du processus actuel à l'exception de la valeur renvoyée. D'un autre côté, l'appel système exec() remplace le processus actuel par un nouveau programme.
Problèmes basés sur C fork()
1. Un processus exécute le code suivant
C
for> (i = 0; i fork();> |
chaîne de longueur
>
>
Le nombre total de processus enfants créés est (PORTE-CS-2008)
(Un
(B) 2 ^ n – 1
(C) 2 ^ n
(D) 2^(n+1) – 1
Voir ceci pour une solution.
2. Considérez le fragment de code suivant :
C
if> (fork() == 0) {> >a = a + 5;> >printf>(>'%d, %d
'>, a, &a);> }> else> {> >a = a –5;> >printf>(>'%d, %d
'>, a, &a);> }> |
>
>
Soit u, v les valeurs imprimées par le processus parent, et x, y les valeurs imprimées par le processus enfant. Lequel des énoncés suivants est VRAI ? (PORTE-CS-2005)
(A) u = x + 10 et v = y
(B) u = x + 10 et v != y
(C) u + 10 = x et v = y
(D) u + 10 = x et v != y
Voir ceci pour une solution.
3. Prédisez la sortie du programme ci-dessous.
C
où sont les paramètres du navigateur
#include> #include> int> main()> > >fork();> >fork() && fork()> |
>
>
Voir ceci pour la solution
Articles Liés :
- Programme C pour démontrer fork() et pipe()
- Processus zombies et orphelins en C
- fork() et processus n/b partagés en mémoire créés à l'aide de celui-ci