Séquence d'instruction d'impression dans fork() appel syatem

Question

Pour obtenir une meilleure compréhension de l'appel système fork(), je joue aléatoirement entre fork() et l'instruction print mais je suis coincé dans un tel code, le code est

#include<stdio.h> 
#include<unistd.h> 
#include<stdlib.h> 
int main() 
{ 
    printf("\n my process id %d \n",getpid()); 
    pid_t pid1=fork(); 
    printf("\nPID:=%d fork returned %d\n",getpid(),pid1); 
    pid_t pid2=fork(); 
    printf("\nPID:=%d fork returned %d\n",getpid(),pid2); 
    pid_t pid3=fork(); 
    printf("\nPID:=%d fork returned %d\n",getpid(),pid3); 
    return 0; 
} 

est ici la sortie obtained-:

Je ne suis pas en mesure d'obtenir la séquence d'impression, il est chose following.Only je reçois est que d'abord le processus avec PID 5079 est en cours d'exécution, et pour tout l'appel système fork(), il renvoie le PID enfant à t Le processus parent. Je n'obtiens pas la séquence suivante.

Answer 1

La fourchette() peut sembler un peu confuse au début, mais c'est en fait assez simple. Ce qu'il fait est de copier le processus en cours dans un nouveau processus dans un autre emplacement de mémoire (copier tout, ses données, le code, l'instruction en cours, ...).

Nous avons donc commencé avec un processus avec pid = 5079, quand nous sommes arrivés à l'appel fork, un processus enfant avec pid = 5080 a été créé, et il a le même code que le processus parent.

// Parent Process //     // Child Process // 
#include<stdio.h>      #include<stdio.h> 
#include<unistd.h>      #include<unistd.h> 
#include<stdlib.h>      #include<stdlib.h> 
int main()        int main() 
{          { 
    printf("\...       printf("\... 
    pid_t pid1=fork();      pid_t pid1=fork(); 
    printf("\nPI... //Next line//  printf("\nPI... //Next line// 
    pid_t pid2=fork();      pid_t pid2=fork(); 
    printf("\nPID:=...      printf("\nPID:=... 
    pid_t pid3=fork();      pid_t pid3=fork(); 
    printf("\nPID:=...      printf("\nPID:=... 
    return 0;        return 0; 
}          } 

avant de continuer suivant le code, la valeur de retour de l'appel de la fourche est la suivante: à l'intérieur du processus qui a appelé la fourche(), la valeur de retour est le pid du processus enfant (variable pid1 à Parent Process = 5080), et dans le processus fils, la sortie est 0 (variable pid1 dans le processus enfant = 0). Donc, l'instruction print après la fourche sera exécutée par le processus parent et le processus fils avec une valeur getpid() différente et des valeurs pid1 différentes, le parent a getpid() = 5079, et pid1 = pid = 5080 (vous pouvez le voir dans la troisième ligne de la sortie). L'enfant va faire sa propre instruction d'impression, avec getpid() = 5080 et pid1 = 0, vous pouvez le voir dans la 8ème ligne de la sortie, mais pourquoi la 8ème ligne !!!

Le système d'exploitation planifie le processus, c'est-à-dire qu'il décide du processus sur lequel le processeur va travailler et pour combien de temps. il semble donc que l'OS a décidé que le processus parent (pid = 5079) devrait fonctionner un peu plus longtemps, et a laissé le processus enfant (pid = 5080) attendre que le CPU exécute ses instructions. Donc le processus 5079 a continué avec la prochaine fourche, créant un nouveau processus fils avec pid = 5081. Ensuite, il a imprimé ce que nous attendions dans la troisième ligne, puis il est passé au dernier processus de création de fourche 5082, en imprimant ce que nous attendrait dans la quatrième ligne, puis se terminant (processus 5079 terminé, laissant 5080,5081,5082 en attente, et adopté par le système d'exploitation, ils doivent avoir un parent, mais ce n'est pas important pour la sortie).

Maintenant que 5079 s'est terminé, nous avons 3 processus en attente dans la mémoire pour que le CPU les utilise. Le système d'exploitation doit décider quel processus à exécuter, et il semble avoir choisir le processus qui est le plus proche de mettre fin, ce qui est processus 5082, regardons les autres instructions pour chaque processus:

// process 5082 //  // process 5081 //  // process 5080 // 
    printf("\nP...   printf("\nP...   printf("\nP... 
    return 0;    pid_t pid3=fork();  pid_t pid2=fork(); 
          printf("\nP...   printf("\nP... 
          return 0;    pid_t pid3=fork(); 
               printf("\nP... 
               return 0; 

Pourquoi l'est code restant? Tout processus créé par une fourche dans un autre processus commencera à s'exécuter après cette instruction fork comme nous l'avons vu précédemment. donc traiter 5082 ligne imprimée 5 alors terminée (sa valeur de pid3 = 0 parce que c'est un enfant de 5079). Après la fin de 5082, 5081 a pris le CPU, et il a imprimé la ligne 6, puis a créé le processus 5085 comme nous pouvons le voir dans la ligne 6 (pourquoi pas 5083 dans l'ordre? Peut-être que l'OS a créé un processus pendant l'exécution de votre code).

après l'impression de la ligne 6, le processus 5081 s'est terminé. Maintenant, nous avons 5080 et 5085 dans la mémoire. vous devriez maintenant être en mesure de suivre le modèle, 5080 a été sélectionné pour fonctionner, créant 5086 et 5087 puis se terminant. puis 5085 a couru, suivi par 5087, qui a seulement eu la déclaration d'impression à la fin, tous les deux alors terminés, et nous sommes partis avec 5086 qui a imprimé, a fait la dernière fourchette créant 5088, puis s'est terminé comme 5088 après son impression.

Systèmes d'exploitation est un domaine fascinant, son plaisir d'aller au-delà des appels système, si vous êtes intéressé par ce que je recommande ce livre, il est ce que j'ai étudié au collège: https://www.amazon.com/Operating-System-Concepts-Abraham-Silberschatz/dp/0470128720