Pourquoi ce programme d'impression “en fourche!” 4 fois?

L'on vient de main() et les trois autres de chaque fork().

Notez que tous les trois forks() vont être exécutés. Vous voudrez peut-être jeter un oeil à la ref:

VALEUR DE RETOUR

À la réussite, fork() doit retourner 0 pour le processus de l'enfant et doit retourner l'ID de processus du processus enfant pour le parent du processus de. Les deux processus doivent continuer à s'exécuter à partir du fork() fonction. Sinon, -1 est renvoyé au processus parent, aucun enfant ne doit être créé, et errno est définie pour indiquer l'erreur.

Notez que l'id de processus ne peut pas être égal à zéro, comme indiqué ici.

---

Donc ce qui se passe vraiment?

Nous avons:

fork() && (fork() || fork());

Donc la première fork() sera de retour à la mère de sa non nul, l'id du processus, alors qu'il sera de retour 0 pour le processus de l'enfant. Cela signifie que l'expression logique de la première fourche sera évaluée à true dans le processus parent, tandis que dans le processus de l'enfant, elle sera évaluée à false et que, en raison de Court-circuit de l'évaluation, il ne sera pas appeler les deux autres fork()s.

Maintenant, on sait qu'on va recevoir au moins deux tirages (un principal et un de la 1ère fork()).

Maintenant, le 2ème fork() dans le processus parent va être exécutée, elle est et elle renvoie une valeur non nulle pour le processus parent et un zéro dans le processus de l'enfant.

Alors maintenant, le parent ne se poursuivra pas l'exécution de la dernière fork() (par court-circuit), tandis que le processus enfant d'exécuter la dernière fourche, depuis le premier opérande de || est de 0.

Cela signifie donc que nous aurons plus de deux tirages.

Comme un résultat, nous obtenons quatre tirages au total.

---

Court-circuit

Ici, court-circuit signifie essentiellement que si le premier opérande de && est zéro, alors l'autre opérande(s) est/ne sont pas évalués. Sur la même logique, si un opérande d'un || est-1, puis le reste de la opérandes n'avez pas besoin d'évaluation. Cela se produit parce que le reste de la opérandes ne peut pas changer le résultat de la logique de l'expression, de sorte qu'ils n'ont pas besoin d'être exécuté, donc nous gagnons du temps.

Voir l'exemple ci-dessous.

---

Processus

Rappelez-vous qu'un processus père crée la descendance des processus qui, à leur tour, créent des les autres processus et ainsi de suite. Cela conduit à une hiérarchie de processus (ou d'un arbre que l'on pourrait dire).

Ayant ceci à l'esprit, il vaut la peine de prendre un coup d'oeil à ce problème similaire, ainsi que cette réponse.

---

Descriptif de l'image

J'ai fait aussi cette figure qui peut aider, je suppose. J'ai supposé que le pid du fork() retournés sont 3, 4 et 5 pour chaque appel.

Notez que certains fork()s X rouge au-dessus d'eux, ce qui signifie qu'ils ne sont pas exécutées à cause du court-circuit de l'évaluation de l'expression logique.

La fork()s en haut ne sont pas va être exécuté, car le premier opérande de l'opérateur && est 0, donc l'ensemble de l'expression sera résultat en 0, donc pas d'essence dans l'exécution du reste de l'opérande(s) de &&.

La fork() au fond ne sera pas exécuté, car c'est la deuxième opérande d'une ||, où son premier opérande est un nombre différent de zéro, donc le résultat de l'expression est déjà évalué à vrai, peu importe ce que le deuxième opérande est.

Et dans l'image suivante vous pouvez voir la hiérarchie des processus:

basé sur la figure précédente.

---

Exemple de Court-Circuit

#include <stdio.h>

int main(void) {

  if(printf("A printf() results in logic true\n"))
    ;//empty body

  if(0 && printf("Short circuiting will not let me execute\n"))
    ;
  else if(0 || printf("I have to be executed\n"))
    ;
  else if(1 || printf("No need for me to get executed\n"))
    ;
  else
  printf("The answer wasn't nonsense after all!\n");

  return 0;
}

De sortie:

A printf() results in logic true
I have to be executed

OriginalL'auteur gsamaras

L'exécution de fork() && (fork() || fork()), ce qui se passe

Chaque fork donne 2 processus avec respectivement des valeurs de pid (parent) et 0 (enfant)

Première bifurcation :

• parent valeur de retour pid est pas null => exécute la && (fork() || fork())
  • deuxième fourche valeur de parent pid est pas null s'arrête l'exécution de la || partie => print forked
  • deuxième fourche enfant valeur = 0 => exécute la || fork()
    • troisième fourche parent imprime forked
    • troisième fourche enfant imprime forked
• enfant valeur de retour est 0 arrêt de l'exécution de la && => imprimés forked

Total : 4 forked

OriginalL'auteur Serge Ballesta

Ce code:

fork();
fork() && fork() || fork();
fork();

obtient 20 processus pour lui-même et 20 fois Printf va aller.

Et pour

fork() && fork() || fork();

printf ira un total de 5 fois.

OriginalL'auteur Mayank Dixit