comprendre fork (), sleep () et traiter les stream

Pratiqué avec ces appels système, mais je me suis coincé dans ce code:

#include  #include  #include  #include  main() { pid_t pid; switch(pid = fork()) { case -1: printf("fork failed"); break; case 0: //first child printf("\ni'm the first child, my pid is %d", getpid()); fflush(stdout); break; default: //parent sleep(5); /** sleep is generating problems **/ printf("\ni'm the parent process, my pid is %d", getpid()); printf("\ngenerating a new child"); fflush(stdout); switch(pid = fork()) { case -1: printf("fork failed"); break; case 0: //second child printf("\nhere i am, the second child, my pid is %d", getpid()); break; default: //parent wait((int *)0); printf("\nback to parent, my pid is %d", getpid()); } } return 0; } 

Le résultat obtenu est:

  je suis le premier enfant, mon pid est 6203
 je suis le processus parent, mon pid est 6202
 générer un nouvel enfant
 Retour aux parents, mon pid est 6202
 Le processus a renvoyé 0 (0x0) temps d’exécution: 5.004 s
 Appuyez sur ENTER pour continuer

 me voici, le deuxième enfant, mon pid est 6204 

Ce que j’essaie, c’est une simple impression de ces messages qui gèrent le minutage via sleep() . Je ne comprends pas pourquoi le programme revient avant d’imprimer le deuxième message enfant. Le cas par défaut (celui juste après la deuxième fourchette) a été imprimé avant que son enfant (deuxième) agisse sur la sortie comme s’il ignorait son wait() . Son enfant a donc été imprimé après le retour du processus.

Je n’ai pas pu comprendre quel est le problème. J’ai marqué la fonction sleep () depuis si je la remplace par wait((int *)0); le stream de processus fonctionne comme il a été conçu (de toute façon, sans aucun timing). À ce stade, je ne suis plus sûr du stream de processus ni de l’utilisation de sleep () (les pages de manuel n’étaient pas très utiles, beaucoup trop concises pour être honnêtes).

En fait, votre appel à attendre fonctionne. Il détecte la fin du premier processus enfant et se poursuit ensuite. Si vous passez deux appels consécutifs à wait (), vous obtiendrez le comportement approprié.

Code de test mis à jour:

 #include  #include  #include  #include  main() { pid_t pid; int status; switch(pid = fork()) { case -1: printf("fork failed"); break; case 0: //first child printf("\ni'm the first child, my pid is %d", getpid()); fflush(stdout); break; default: //parent sleep(5); /** sleep is generating problems **/ printf("\ni'm the parent process, my pid is %d", getpid()); printf("\ngenerating a new child"); fflush(stdout); switch(pid = fork()) { case -1: printf("fork failed"); break; case 0: //second child printf("\nhere i am, the second child, my pid is %d", getpid()); break; default: //parent pid = wait(&status); printf("\nParent detects process %d was done", pid); pid = wait(&status); printf("\nParent detects process %d was done", pid); printf("\nback to parent, my pid is %d", getpid()); } } return 0; } 

Sortie:

 i'm the first child, my pid is 30897 i'm the parent process, my pid is 30896 generating a new child here i am, the second child, my pid is 30940 Parent detects process 30897 was done Parent detects process 30940 was done back to parent, my pid is 30896 

La page de manuel relative à wait indique ce qui suit:

La fonction wait () suspend l’exécution du thread appelant jusqu’à ce que les informations de statut de l’un des processus enfants terminés du processus appelant soient disponibles, ou jusqu’à la livraison d’un signal dont l’action consiste à exécuter une fonction de capture de signal ou à terminer processus. Si plusieurs threads sont suspendus dans wait () ou waitpid () dans l’attente de la fin du même processus, un seul thread doit renvoyer l’état du processus au moment de la fin du processus cible.

Attendre revient à cause du premier enfant.