La sortie de processus est une opération courante dans les systèmes Linux. Elle permet à un processus de mettre fin à sa propre opération, de libérer les ressources qu'il occupe et de revenir à son propre état. Il existe de nombreuses raisons pour lesquelles un processus se termine, comme terminer des tâches normalement, rencontrer des erreurs, recevoir des signaux, etc. Il existe de nombreuses façons de quitter un processus, par exemple en utilisant exit(), return, _exit(), abort() et d'autres fonctions ou instructions. Mais savez-vous vraiment comment quitter un processus Linux ? Savez-vous comment utiliser et choisir la méthode de sortie de processus appropriée sous Linux ? Savez-vous comment terminer un processus en douceur sous Linux ? Cet article vous présentera en détail les connaissances pertinentes sur la sortie du processus Linux, afin que vous puissiez mieux utiliser et comprendre cette opération courante sous Linux.
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.
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.
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.
_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 certaines autres fonctions de nettoyage du noyau, mais ne rafraîchira pas le flux (stdin, stdout, stderr...). au-dessus de la fonction _exit Un wrapper 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'instance de fonction 2 en printf("This is the content in buffern") (c'est-à-dire ajouter un n à la fin de printf pour voir quel est le résultat est. Pourquoi cela arrive-t-il ?)
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 dont le 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.
Grâce à cet article, vous devez avoir une compréhension complète des méthodes de sortie des processus Linux et connaître leur définition, leurs principes, leur utilisation, leurs avantages et leurs inconvénients. Vous devez également comprendre les causes et les effets de la sortie de processus, ainsi que comment utiliser et sélectionner correctement les méthodes de sortie de processus sous Linux. Nous vous recommandons, lorsque vous utilisez un système Linux, d'utiliser des méthodes de sortie de processus appropriées pour mettre fin au processus afin d'améliorer la stabilité et l'efficacité du système. Dans le même temps, nous vous rappelons également de prêter attention à certains problèmes et défis potentiels lors de l'utilisation de la méthode de sortie de processus, tels que les processus zombies, les fuites de mémoire, la gestion des signaux, etc. J'espère que cet article pourra vous aider à mieux utiliser le système Linux et vous permettre de terminer le processus en douceur sous Linux.
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!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
