Appel du système de fourche dans c

L'appel système Fork () est utilisé pour créer des processus enfants dans un programme C. Fork () est utilisé lorsque le traitement parallèle est requis dans votre application. La fonction système Fork () est définie dans les en-têtes sys / types.H et unistd.H. Dans un programme où vous utilisez Fork, vous devez également utiliser l'appel d'attente (). L'appel du système Wait () est utilisé pour attendre dans le processus parent que le processus de l'enfant se termine. Pour terminer un processus d'enfant, l'appel du système de sortie () est utilisé dans le processus enfant. La fonction attend () est définie dans l'en-tête sys / attendre.H et la fonction d'exit () est définie dans l'en-tête stdlib.H.

Fig 1: flux de travail de base Fork ()

Dans cet article, je vais vous montrer comment utiliser l'appel système Fork () pour créer des processus enfants en C. Alors, commençons.

Valeur de syntaxe et de retour de la syntaxe et de retour:

La syntaxe de la fonction système Fork () est la suivante:

PID_T Fork (void);

La fonction système Fork () n'accepte aucun argument. Il renvoie un entier du type pid_t.

Sur le succès, Fork () renvoie le PID du processus de l'enfant qui est supérieur à 0. À l'intérieur du processus de l'enfant, la valeur de retour est 0. Si Fork () échoue, alors il renvoie -1.

Exemple de Fork () simple:

Un exemple de fourche simple () est donné ci-dessous:

#inclure
#inclure
#inclure
#inclure
#inclure
int main (void)
pid_t pid = fork ();
if (pid == 0)
printf ("child => ppid:% d pid:% d \ n", getppid (), getPid ());
exit (exit_success);

else if (pid> 0)
printf ("parent => pid:% d \ n", getpid ());
printf ("En attente du processus d'enfant pour terminer.\ n ");
attendre (null);
printf ("Processus enfant terminé.\ n ");

autre
printf ("Impossible de créer un processus d'enfant.\ n ");

return exit_success;

Ici, j'ai utilisé Fork () pour créer un processus enfant à partir du processus principal / parent. Ensuite, j'ai imprimé le PID (ID de processus) et PPID (ID de processus parent) du processus d'enfant et parent. Sur le processus parent, attendre (null) est utilisé pour attendre la fin du processus de l'enfant. Sur le processus de l'enfant, la sortie () est utilisée pour terminer le processus de l'enfant. Comme vous pouvez le voir, le PID du processus parent est le PPID du processus de l'enfant. Donc, le processus de l'enfant 24738 appartient au processus parent 24731.

Vous pouvez également utiliser des fonctions pour rendre votre programme plus modulaire. Ici, j'ai utilisé processTask () et parentTask () Fonctions pour les processus enfants et parents respectivement. C'est ainsi que Fork () est réellement utilisé.

#inclure
#inclure
#inclure
#inclure
#inclure
void childTask ()
printf ("Hello World \ n");

void parentTask ()
printf ("Tâche principale.\ n ");

int main (void)
pid_t pid = fork ();
if (pid == 0)
ChildTask ();
exit (exit_success);

else if (pid> 0)
attendre (null);
parentTask ();

autre
printf ("Impossible de créer un processus d'enfant.");

return exit_success;

La sortie du programme ci-dessus:

Exécution de plusieurs processus enfants en utilisant Fork () et Loop:

Vous pouvez également utiliser Loop pour créer autant de processus enfants que vous avez besoin. Dans l'exemple ci-dessous, j'ai créé 5 processus enfants en utilisant pour Loop. J'ai également imprimé le PID et PPID des processus enfants.

#inclure
#inclure
#inclure
#inclure
#inclure
int main (void)
pour (int i = 1; i <= 5; i++)
pid_t pid = fork ();
if (pid == 0)
printf ("child process => ppid =% d, pid =% d \ n", getppid (), getPid ());
sortie (0);

autre
printf ("process parent => pid =% d \ n", getPid ());
printf ("en attente de processus d'enfants pour terminer… \ n");
attendre (null);
printf ("Processus enfant terminé.\ n ");


return exit_success;

Comme vous pouvez le voir, l'ID de processus parent est le même dans tous les processus enfants. Donc, tous appartiennent au même parent. Ils exécutent également de manière linéaire. L'un après l'autre. Le contrôle des processus enfants est une tâche sophistiquée. Si vous en apprenez plus sur la programmation du système Linux et comment cela fonctionne, vous pourrez contrôler le flux de ces processus de toute façon.

Exemple de la vie réelle:

Différents calculs mathématiques complexes tels que MD5, SHA256, etc. La génération de hachage nécessite beaucoup de puissance de traitement. Au lieu de calculer des choses comme ça dans le même processus que le programme principal, vous pouvez simplement calculer le hachage sur un processus enfant et renvoyer le hachage au processus principal.

Dans l'exemple suivant, j'ai généré un code PIN à 4 chiffres dans un processus d'enfant et je l'ai envoyé au processus parent, le programme principal. Ensuite, j'ai imprimé le code PIN à partir de là.

#inclure
#inclure
#inclure
#inclure
#inclure
int getpin ()
// Utilisez PPID et PID comme graine
srand (getPid () + getppid ());
int secret = 1000 + rand ()% 9000;
retour secret;

int main (void)
int fd [2];
tuyau (FD);
pid_t pid = fork ();
if (pid> 0)
Fermer (0);
Close (FD [1]);
dup (fd [0]);
int secretNumber;
size_t readBytes = read (fd [0], & secretNumber, sizeof (SecretNumber));
printf ("En attendant la broche… \ n");
attendre (null);
printf ("octets lus:% ld \ n", readBytes);
printf ("broche:% d \ n", secretNumber);

else if (pid == 0)
ferme (1);
close (fd [0]);
dup (fd [1]);
int secret = getPin ();
écrire (fd [1], & secret, sizeof (secret));
exit (exit_success);

return exit_success;

Comme vous pouvez le voir, chaque fois que j'exécute le programme, j'obtiens un autre code PIN à 4 chiffres.

Donc, c'est essentiellement ainsi que vous utilisez l'appel système Fork () dans Linux. Merci d'avoir lu cet article.