Système de fourche appelle Linux

L'appel du système de fourche est utilisé pour créer un nouveau processus. Le processus nouvellement créé est le processus enfant. Le processus qui appelle Fork et crée un nouveau processus est le processus parent. Les processus enfants et parents sont exécutés simultanément.

Mais les processus enfants et parents résident sur différents espaces de mémoire. Ces espaces de mémoire ont le même contenu et toute opération effectuée par un processus n'affectera pas l'autre processus.

Lorsque l'enfant traite les processus; Maintenant, les deux processus auront le même compteur de programme (PC), donc ces deux processus indiqueront la même prochaine instruction. Les fichiers ouverts par le processus parent seront les mêmes pour le processus d'enfant.

Le processus de l'enfant est exactement le même que son parent, mais il y a une différence dans les processus d'identification:

1. L'identification du processus du processus enfant est un identifiant de processus unique qui est différent de l'ID de tous les autres processus existants.
2. L'identification du processus parent sera la même que celle de l'ID de processus du parent de l'enfant.

Propriétés du processus enfant

Voici quelques-unes des propriétés d'un processus d'enfant:

1. Les compteurs du processeur et les utilisations des ressources sont initialisés pour se réinitialiser à zéro.
2. Lorsque le processus parent est résilié, les processus enfants ne reçoivent aucun signal car l'attribut PR_SET_PDEATHSIG dans PRCTL () est réinitialisé.
3. Le fil utilisé pour appeler Fork () crée le processus de l'enfant. L'adresse du processus enfant sera donc la même que celle du parent.
4. Le descripteur de fichier du processus parent est hérité par le processus de l'enfant. Par exemple, le décalage du fichier ou de l'état des drapeaux et des attributs d'E / S sera partagé entre les descripteurs de fichiers des processus enfants et parents. Ainsi, le descripteur de fichiers de la classe parent se réfère au même descripteur de fichiers de la classe enfant.
5. Les descripteurs de file d'attente de messages ouverts du processus parent sont hérités par le processus de l'enfant. Par exemple, si un descripteur de fichiers contient un message dans le processus parent, le même message sera présent dans le descripteur de fichier correspondant de l'enfant Process. Nous pouvons donc dire que les valeurs de drapeau de ces descripteurs de fichiers sont les mêmes.
6. Les flux de répertoires ouverts de la même manière seront hérités par les processus enfants.
7. La valeur de relâchement de la minuterie par défaut de la classe enfant est la même que la valeur de lâche du temporisateur actuel de la classe parent.

Propriétés qui ne sont pas héritées par le processus enfant

Voici quelques-unes des propriétés qui ne sont pas héritées par un processus d'enfant:

1. Serrures de mémoire
2. Le signal en attente d'une classe d'enfants est vide.
3. Processus des verrous d'enregistrement associés (fcntl ())
4. Opérations d'E / S asynchrones et contenu d'E / S.
5. Notifications de changement de répertoire.
6. Les minuteries telles que Alarm (), setitimer () ne sont pas héritées par la classe infantile.

fork () en c

Il n'y a pas d'arguments dans Fork () et le type de retour de Fork () est entier. Vous devez inclure les fichiers d'en-tête suivants lorsque Fork () est utilisé:

#inclure
#inclure
#inclure

Lorsque vous travaillez avec Fork (), peut être utilisé pour le type pid_t Pour les processus, les identifiants comme PID_T sont définis dans .

Le fichier d'en-tête est l'endroit où Fork () est défini, vous devez donc l'inclure à votre programme pour utiliser Fork ().

Le type de retour est défini dans et Fork () L'appel est défini dans . Par conséquent, vous devez inclure les deux dans votre programme pour utiliser l'appel système Fork ().

Syntaxe de Fork ()

La syntaxe de l'appel système Fork () dans Linux, Ubuntu est la suivante:

PID_T Fork (void);

Dans la syntaxe, le type de retour est pid_t. Lorsque le processus de l'enfant est créé avec succès, le PID du processus de l'enfant est retourné dans le processus parent et 0 sera retourné au processus de l'enfant lui-même.

S'il y a une erreur, alors -1 est renvoyé au processus parent et le processus de l'enfant n'est pas créé.

Aucun argument n'est passé à Fork ().

Exemple 1: appel à fork ()

Considérez l'exemple suivant dans lequel nous avons utilisé l'appel système Fork () pour créer un nouveau processus enfant:

#inclure
#inclure
#inclure
int main()

fourchette();
printf ("Using Fork () System Call \ n");
retour 0;

SORTIR:

sysads @ Linuxhint $ gcc.C -o Fork
sysads @ linuxhint $ ./fourchette
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()

Dans ce programme, nous avons utilisé Fork (), cela créera un nouveau processus enfant. Lorsque le processus de l'enfant est créé, le processus parent et le processus de l'enfant pointent vers l'instruction suivante (même compteur de programme). De cette façon, les instructions ou les instructions restantes seront exécutées le nombre total de temps de processus, c'est-à-dire 2ⁿ fois, où n est le nombre d'appels système Fork ().

Ainsi, lorsque l'appel Fork () est utilisé une fois comme ci-dessus (2¹ = 2) Nous aurons notre sortie 2 fois.

Ici, lorsque l'appel système Fork () est utilisé, la structure interne ressemblera à:

Considérez le cas suivant dans lequel la fourche () est utilisée 4 fois:

#inclure
#inclure
#inclure
int main()

fourchette();
fourchette();
fourchette();
fourchette();
printf ("Using Fork () System Call \ n");
retour 0;

Sortir:

sysads @ Linuxhint $ gcc.C -o Fork
sysads @ linuxhint $ ./fourchette
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
Utilisation d'appel système Fork ()
sysads @ linuxhint $

Maintenant, le nombre total de processus créés est 2⁴ = 16 Et nous avons notre déclaration imprimée exécutée 16 fois.

Exemple 2: Tester si Fork () a réussi

Dans l'exemple suivant, nous avons utilisé la construction de prise de décision pour tester la valeur (int) renvoyée par fork (). Et les messages correspondants sont affichés:

#inclure
#inclure
#inclure
int main()

pid_t p;
p = fork ();
if (p == - 1)

printf ("Il y a une erreur en appelant Fork () \ n");

if (p == 0)

printf ("Nous sommes dans le processus enfant \ n");

autre

printf ("Nous sommes dans le processus parent \ n");

retour 0;

SORTIR:

sysads @ Linuxhint $ gcc.C -o Fork
sysads @ linuxhint $ ./fourchette
Nous sommes dans le processus parent
Nous sommes dans le processus enfant

Dans l'exemple ci-dessus, nous avons utilisé le type PID_T qui stockera la valeur de retour de Fork (). Fork () est appelé en ligne:

p = fork ();

Ainsi, la valeur entière renvoyée par Fork () est stockée en p puis P est comparée pour vérifier si notre appel Fork () a réussi.

Lorsque l'appel Fork () est utilisé et que l'enfant est créé avec succès, l'ID du processus de l'enfant sera retourné au processus parent et 0 sera retourné au processus de l'enfant.L'identification du processus de l'enfant dans le processus parent ne sera pas la même que le processus d'identification du processus de l'enfant dans le processus de l'enfant lui-même. Dans le processus d'enfant, l'identification du processus enfant sera 0.

Avec ce tutoriel, vous pouvez voir comment démarrer avec l'appel du système de fourche dans Linux.