Méthodologie : Comprendre la méthode de sortie du processus Linux

Présentation

Lorsqu'un processus se termine ou se termine à mi-chemin, le noyau doit libérer les ressources système occupées par le processus. Cela inclut les fichiers ouverts pendant l'exécution du processus, la mémoire demandée, etc.

Sortie du processus

La sortie d'un processus sous Linux se divise en deux types : sortie normale et sortie anormale :

1.Sortez normalement

a. Exécutez return dans la fonction main().

b. Appelez la fonction exit()

c. Appelez la fonction _exit()

2.Sortir anormalement

a. Appelez pour la fonction

b. Le processus reçoit un signal et le signal entraîne la fin du programme.

Quelle que soit la méthode de sortie utilisée, le système finira par exécuter le même code dans le noyau. Ce code est utilisé pour fermer le descripteur de fichier ouvert utilisé par le processus et libérer la mémoire et les autres ressources qu'il occupe.

Comparaison de plusieurs méthodes de sortie

1. La différence entre la sortie et le retour :

exit est une fonction avec des paramètres. Une fois la sortie exécutée, le contrôle est transféré au système

return est le retour après l'exécution de la fonction. Une fois le retour exécuté, le contrôle est transféré à la fonction appelante.

2. La différence entre la sortie et l'abandon :

la sortie est la fin normale du processus

about est une terminaison anormale.

Fonctions exit() et _exit()

Les fonctions exit et _exit sont toutes deux utilisées pour terminer le processus. Lorsque le programme exécute exit ou _exit, le système arrête inconditionnellement toutes les opérations restantes, efface diverses structures de données et met fin à l'exécution du processus.

exit est déclaré dans le fichier d'en-tête stdlib.h, tandis que _exit() est déclaré dans le fichier d'en-tête unistd.h. Le paramètre exit_code dans exit est 0, ce qui signifie que le processus se termine normalement. S'il s'agit d'autres valeurs, cela signifie qu'une erreur s'est produite lors de l'exécution du programme.

La différence entre exit() et _exit()

_exit() retourne au noyau immédiatement après l'exécution, tandis que exit() effectue d'abord quelques opérations de nettoyage, puis confie le contrôle au noyau.

Lorsque la fonction _exit est appelée, elle fermera tous les descripteurs de fichiers du processus, nettoiera la mémoire et les autres fonctions de nettoyage du noyau, mais ne rafraîchira pas le flux (stdin, stdout, stderr...). la fonction _exit Un wrapper sur _exit qui appelle _exit et vide le flux avant de l'appeler.

La plus grande différence entre la fonction exit() et la fonction _exit() est que la fonction exit() vérifie l'état d'ouverture du fichier et réécrit le contenu du tampon de fichier dans le fichier avant d'appeler le système de sortie. Parce qu'il existe une opération appelée « E/S tamponnées » dans la bibliothèque de fonctions standard Linux, sa caractéristique est qu'il existe un tampon dans la mémoire correspondant à chaque fichier ouvert. Chaque fois qu'un fichier est lu, plusieurs enregistrements seront lus en continu, de sorte que la prochaine fois que le fichier sera lu, il pourra être lu directement à partir de la mémoire tampon, de la même manière, chaque fois qu'un fichier est écrit, il est uniquement écrit dans la mémoire ; tampon. Lorsque certaines conditions sont remplies (comme atteindre un certain nombre ou rencontrer des caractères spécifiques, etc.), le contenu du tampon est écrit immédiatement dans le fichier. Cette technologie augmente considérablement la vitesse de lecture et d'écriture des fichiers, mais elle pose également quelques problèmes de programmation. Par exemple, on pense que certaines données ont été écrites dans le fichier. En fait, comme elles ne remplissent pas de conditions spécifiques, elles sont uniquement enregistrées dans le tampon. À ce stade, utilisez la fonction _exit() pour fermer directement. le processus et les données dans le tampon seront perdues. Par conséquent, si vous souhaitez garantir l’intégrité des données, vous devez utiliser la fonction exit().

Voyons la différence entre eux à travers un exemple de fonction :

Exemple de fonction 1 : exit.c

#include
#include

int main()
{
printf("using exit----\n");
printf("This is the content in buffer\n");
exit(0);
}

Le résultat de l'exécution est :

using exit----

This is the content in buffer

Exemple de fonction 2 : _exit.c

#include
#include

int main()
{
printf("using _exit--\n");
printf("This is the content in buffer");
_exit(0);
}

Le résultat de l'exécution est :

using _exit--

La fonction printf utilise des E/S tamponnées. Cette fonction lit automatiquement l'enregistrement à partir du tampon lorsqu'elle rencontre le caractère de nouvelle ligne "n". Par conséquent, exit() se termine après avoir écrit les données dans le tampon, tandis que la fonction _exit() se termine directement.

Vous pouvez également modifier printf("This is the content in buffer"); dans l'exemple de fonction 2 en printf("This is the content in buffern") (c'est-à-dire ajouter un n à la fin de printf pour voir le résultat est. Pourquoi cela arrive-t-il ?)

L'ordre différent de fin des processus parent et enfant produira des résultats différents

1. Le processus parent se termine avant le processus enfant :

Cette situation est le processus orphelin que nous avons utilisé plus tôt. Lorsque le processus parent se termine en premier, le système laisse le processus d'initialisation prendre le relais du processus enfant.

2. Le processus enfant se termine avant le processus parent, et le processus parent n'appelle pas la fonction d'attente

Dans ce cas, le processus enfant entre dans un état zombie et le restera jusqu'au redémarrage du système. Lorsque le processus enfant est dans un état zombie, le noyau enregistre uniquement certaines informations nécessaires sur le processus dont le processus parent a besoin. À ce stade, le processus enfant occupe toujours des ressources et réduit également le nombre maximum de processus que le système peut créer.

Quel est l'état du zombie ?

Un processus qui s'est terminé mais que son processus parent n'a pas encore traité les conséquences (obtenir des informations sur le processus enfant terminé et libérer les ressources qu'il occupe encore) est appelé un processus zombie.

3. Le processus enfant se termine avant le processus parent, et le processus parent appelle la fonction d'attente

À ce stade, le processus parent attendra la fin du processus enfant.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!