travail de la fourche en langage c

Maintenant, j’ai du mal à comprendre le fonctionnement de l’appel système fork() . J’écris un code qui suit:

 #include int main() { int a, b; b=fork(); printf("\n the value of b = %d",b); } 

La sortie de ce code est la suivante:

Maintenant, je ne comprends pas pourquoi la sortie est comme ça?

Après cela, je viens d’append une ligne à mon code et la sortie est complètement différente. mon code est le suivant:

 int main() { int a, b; b=fork(); 

Quand je lance le code, la sortie suit 2389mon nom est Manish

  the value of b = 0 

Maintenant, je suis totalement confus quant au fonctionnement de l’appel fork() .

Ma question est la suivante:

  1. Comment fork() fonctionne?
  2. Où va le contrôle après l’appel fork() ?
  3. Quelqu’un peut-il expliquer pourquoi les sorties de codes écrits en problème?
  4. Pourquoi la sortie de b se produisant à différents endroits signifie en premier code que la sortie de b = 2260 est juste avant la sortie b = 0 alors que la valeur de b = 2389 n’est pas juste avant la b = 0 ?

Veuillez m’expliquer le fonctionnement de fork dans le code écrit dans le problème afin que je puisse l’apprendre correctement.

Il peut être utile de commencer par comprendre pourquoi le mot fork a été utilisé pour nommer cette fonction. Avez-vous déjà entendu parler d’une “fourchette sur la route?” À la fourchette, le processus doit diviser les chemins.

Tout d’abord, un processus unique s’exécute normalement jusqu’à ce que vous atteigniez l’appel fork . Lors de l’appel de fork, un nouveau processus est créé, qui est pratiquement identique au processus d’origine, à l’ exception de la valeur de retour de la fonction fork. Le processus nouvellement créé est appelé processus enfant. Le processus qui l’a généré est appelé processus parent.

Étant donné que vous souhaitez effectuer différentes tâches pour chaque twig du fork, vous devez être en mesure de distinguer le processus enfant du processus parent. C’est là que la valeur de retour de fork entre: fork renvoie l’id de processus (pid) de l’enfant (le processus nouvellement créé) au parent; il renvoie 0 à l’enfant. De plus, si l’exécution de fork passe mal, la valeur de retour est -1.

Dans votre code, vous ne faites pas de distinction entre les processus enfant et parent. Par conséquent, les deux processus exécutent l’intégralité du code qui suit après l’appel fork .

 //what the child process looks like after fork is called int main() { int a, b; b=fork(); // <-- current line of execution: 0 is returned to b printf("\nmy name is manish\n"); printf("\n my name is anil\n"); printf("\n the value of b = %d",b); } // what the parent process looks like after fork is called int main() { int a, b; b=fork(); // <-- current line: child process id is returned printf("\nmy name is manish\n"); printf("\n my name is anil\n"); printf("\n the value of b = %d",b); } 

Comme vous pouvez le constater, les deux processus ont le même code après le fork et la sortie est répétée. Peut-être que si vous voulez que le processus parent produise Manish et que l'enfant produise Anil, vous pouvez faire quelque chose comme:

 int main() { pid_t b; // note that the actual return type of fork is // pid_t, though it's probably just an int typedef'd or macro'd b = fork(); if (b == -1) perror("Fork failed"); else if (b > 0) { printf("My name is Manish\n"); // parent process else printf("My name is Anil\n"); // child process printf("The value of b is %d\n", b); return 0; } 

Enfin, le dernier commentaire à faire est que dans votre code, la sortie semble avoir été exécutée en premier par un processus dans son intégralité, puis par l'autre processus dans son intégralité. Cela peut ne pas toujours être le cas. Par exemple, le système d'exploitation peut autoriser le parent à exécuter la sortie 'manish', puis à faire attendre ce processus et à transférer le processeur au processus enfant, qui exécute ensuite 'manish'. Cependant, le processus enfant peut continuer et exécuter les sorties 'anil' et 'b', complétant ainsi l'exécution du processus enfant et renvoyant ainsi l'exécution au processus parent. Maintenant, le parent termine son exécution en affichant 'anil' et 'b' lui-même. Le résultat final de l'exécution de ce programme peut ressembler à:

 mon nom est manish // exécuté par le parent
 mon nom est anil // enfant
 la valeur de b = 0 // enfant
 mon nom est anil // parent
 la valeur de b = 2244 // parent
 manish.yadav@ws40-man-lin: ~ $ 

Consultez la page de manuel de fork . Consultez également waitpid pour une gestion correcte des processus enfants par les processus parents afin de ne pas créer de zombies.

Edit: En réponse à vos questions dans les commentaires, je vais vous dire comment vous pouvez simplement exécuter chaque processus de manière consécutive.

 int main() { pid_t pid; int i; for (i=0; i 0) { // parent process waitpid(-1, NULL, 0); //might want to look at man page for this // it will wait until the child process is done } else { // do whatever each process needs to do; // then exit() doProcess(i); exit(0); } } // do anything else the parent process needs to do return 0; } 

Bien sûr, ce n'est pas le meilleur code, mais c'est juste pour illustrer ce point. La grande idée ici est l'appel waitpid , qui waitpid le processus parent à attendre jusqu'à ce que le processus enfant qu'il vient de terminer se termine. Une fois le processus enfant terminé, le parent continue après l'appel waitpid , en démarrant une autre itération de la boucle for et en forçant un autre processus (le prochain). Cela continue jusqu'à ce que tous les processus enfants aient été exécutés de manière séquentielle et que l'exécution revienne enfin au parent.

  1. Fork crée une copie de votre processus actuel.
  2. L’original et la copie continuent à s’exécuter à partir du moment où fork() été appelé.
  3. Étant donné que votre code est exécuté deux fois, vos instructions d’impression sont également évaluées deux fois. Dans le processus copié, la valeur de b est 0. Dans le processus d’origine, la valeur de b est l’ID de processus du processus copié.
  4. Une fois que vos processus ont commencé à s’exécuter simultanément, ils sont planifiés indépendamment par votre système d’exploitation. Par conséquent, vous n’avez aucune garantie quant au moment où ils seront réellement exécutés.
  1. Le fork est implémenté par le système d’exploitation. Il crée fondamentalement un processus enfant et commence à l’exécuter après le fork() .

  2. Le processus parent reçoit l’ID de processus du processus de fichier: b=fork(); b a l’identifiant du processus. Le processus enfant obtient un pid de zéro.

  3. (et 4) Étant donné que les deux processus peuvent être exécutés en parallèle ou en tranches de temps, votre sortie variera.

Vous voudrez peut-être vérifier ceci: http://en.wikipedia.org/wiki/Fork_(operating_system )

Tu ferais mieux de partir de ça .

Vous trouverez ici une explication et un exemple de code.