L'appel système fork est utilisé pour créer un nouveau processus. Le processus nouvellement créé est le processus fils. Le processus qui appelle fork et crée un nouveau processus est le processus parent. Les processus enfant et parent sont exécutés simultanément.
Mais les processus fils et parents résident sur des espaces mémoire différents. Ces espaces mémoire ont le même contenu et toute opération effectuée par un processus n'affectera pas l'autre processus.
Lorsque le processus enfant est créé ; maintenant, les deux processus auront le même compteur de programme (PC), de sorte que ces deux processus pointent vers la même instruction suivante. Les fichiers ouverts par le processus parent seront les mêmes pour le processus enfant.
Le processus enfant est exactement le même que son parent, mais il existe une différence dans les ID de processus :
- L'ID de processus du processus enfant est un ID de processus unique qui est différent des ID de tous les autres processus existants.
- L'ID de processus parent sera le même que celui de l'ID de processus du parent de l'enfant.
Propriétés du processus enfant
Voici quelques-unes des propriétés détenues par un processus enfant :
- Les compteurs CPU et les utilisations des ressources sont initialisés pour être remis à zéro.
- Lorsque le processus parent est terminé, les processus enfants ne reçoivent aucun signal car l'attribut PR_SET_PDEATHSIG dans prctl() est réinitialisé.
- Le thread utilisé pour appeler fork() crée le processus fils. L'adresse du processus fils sera donc la même que celle du processus parent.
- Le descripteur de fichier du processus parent est hérité par le processus enfant. Par exemple, l'offset du fichier ou l'état des indicateurs et les attributs d'E/S seront partagés entre les descripteurs de fichiers des processus enfants et parents. Ainsi, le descripteur de fichier de la classe parent fera référence au même descripteur de fichier de la classe enfant.
- Les descripteurs de file d'attente de messages ouverts du processus parent sont hérités par le processus enfant. Par exemple, si un descripteur de fichier contient un message dans le processus parent, le même message sera présent dans le descripteur de fichier correspondant du processus enfant. Nous pouvons donc dire que les valeurs des drapeaux de ces descripteurs de fichiers sont les mêmes.
- De même, les flux de répertoires ouverts seront hérités par les processus enfants.
- La valeur d'écart du temporisateur par défaut de la classe enfant est la même que la valeur d'écart du temporisateur actuelle 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 enfant :
- Verrouillage de la mémoire
- Le signal en attente d'une classe enfant est vide.
- Traiter les verrous d'enregistrement associés (fcntl())
- Opérations d'E/S asynchrones et contenus d'E/S.
- Notifications de changement de répertoire.
- Les temporisateurs tels que alarm(), setitimer() ne sont pas hérités par la classe enfant.
fourche() en C
Il n'y a pas d'arguments dans fork() et le type de retour de fork() est un entier. Vous devez inclure les fichiers d'en-tête suivants lorsque fork() est utilisé :
#comprendre
#comprendre
#comprendre
Lorsque vous travaillez avec fork(), peut être utilisé pour le type pid_t pour les ID de processus comme pid_t est défini dans .
Le fichier d'en-tête est l'endroit où fork() est défini, vous devez donc l'inclure dans votre programme pour utiliser fork().
Le type de retour est défini dans et l'appel fork() 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() sous Linux, Ubuntu est la suivante :
pid_t fork(void);Dans la syntaxe, le type de retour est pid_t . Lorsque le processus enfant est créé avec succès, le PID du processus enfant est renvoyé dans le processus parent et 0 sera renvoyé au processus enfant lui-même.
S'il y a une erreur, -1 est renvoyé au processus parent et le processus enfant n'est pas créé.
No arguments are passed to fork().
Exemple 1 : Appeler fork()
Considérons l'exemple suivant dans lequel nous avons utilisé l'appel système fork() pour créer un nouveau processus enfant :
CODE:
#comprendre#comprendre
#comprendre
entierprincipale()
{
fourchette();
imprimer ('Utilisation de l'appel système fork() ');
revenir 0;
}
SORTIR:
Utiliser l'appel système fork()Utiliser l'appel système fork()
Dans ce programme, nous avons utilisé fork(), cela créera un nouveau processus enfant. Lorsque le processus enfant est créé, le processus parent et le processus enfant pointent vers l'instruction suivante (même compteur de programme). De cette façon, les instructions ou instructions C restantes seront exécutées le nombre total de fois de processus, c'est-à-dire 2mfois, où n est le nombre d'appels système fork().
Ainsi, lorsque l'appel fork() est utilisé une fois comme ci-dessus (21= 2) nous aurons notre sortie 2 fois.
Ici, lorsque l'appel système fork() est utilisé, la structure interne ressemblera à :
Considérons le cas suivant dans lequel le fork() est utilisé 4 fois :
CODE:
#comprendre#comprendre
#comprendre
entierprincipale()
{
fourchette();
fourchette();
fourchette();
fourchette();
imprimer ('Utiliser l'appel système fork()');
revenir 0;
}
Sortir:
Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call Using fork() system call
Maintenant, le nombre total de processus créés est de 24= 16 et nous avons notre instruction print 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 s'affichent :
CODE:
#comprendre#comprendre
#comprendre
entierprincipale()
{
pid_t p;
p=fourchette();
si(p== -1)
{
imprimer ('Il y a une erreur lors de l'appel de fork()');
}
si(p==0)
{
imprimer (« Nous sommes dans le processus de l'enfant »);
}
autre
{
imprimer (« Nous sommes dans le processus parental »);
}
revenir 0;
}
SORTIR:
Nous sommes dans le processus parentNous 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=fourchette();Ainsi, la valeur entière renvoyée par fork() est stockée dans 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 enfant sera renvoyé au processus parent et 0 sera renvoyé au processus enfant. L'ID du processus enfant dans le processus parent ne sera pas le même que le ID du processus enfant dans le processus enfant lui-même. Dans le processus enfant, l'ID du processus enfant sera 0.
Avec ce tutoriel, vous pouvez voir comment démarrer avec l'appel système fork sous Linux.