Processus Zombie

– Quels sont les avantages du concept de processus zombie?

Un processus zombie est juste un pid, un état de sortie et des informations de comptabilité qui restnt jusqu’à ce qu’un parent utilise l’un des appels de la famille d’appels système pour obtenir son statut final. Jusqu’à ce qu’un appel parent wait l’ID de processus de l’enfant doit restr marqué comme utilisé afin qu’aucun autre processus ne puisse lui être affecté. Si un autre processus devait se voir atsortingbuer un pid recyclé, il serait difficile de faire la différence entre ce processus et les processus antérieurs ayant le même pid. Une fois que l’ wait est appelée par le parent et renvoie un statut de sortie final, on peut supposer que personne ne cherchera à nouveau l’enfant à ce pid, de sorte que le pid peut maintenant être réutilisé. (Je pense que sous Linux, si un parent quitte SIGCHLD comme SIG_IGN, le kernel ne gardera pas les zombies, mais que réenregistrer la disposition de SIGCHLD comme SIG_IGN n’a pas le même effet)

– sachez que le kernel conserve (PID, état de la terminaison, informations d’utilisation des ressources) pour le processus zombie, quelle est la signification des “informations d’utilisation des ressources”

Une partie de cette information est ce qui exécute un programme en tant que:

 time my_program 

Informera. Ces valeurs sont généralement signalées dans la structure siginfo pour SIGCHLD (qui n’est pas exactement un appel à wait ), mais également disponibles à partir d’un appel à la forme serveur de l’appel systme (sur certains systèmes). Regardez l’ man sigaction pour plus d’informations sur cette structure.

– comment PPID () de zombie = 1 et il zombie toujours, (init récupère les zombies car il attend () par défaut)

Un zombie dont ppid = 1 ne devrait pas restr un zombie très longtemps car init devrait le récupérer assez rapidement. Un processus restra un zombie à partir d’un point peu de temps après sa mort (soit par la exit soit par un signal non manipulé qui le tue) jusqu’à ce que ses appels parents wait et obtiennent son statut final. Cela signifie que même si init ne fait rien mais appelle init, il peut y avoir un petit laps de temps où un processus peut apparaître comme un zombie. Si les processus apparaissent comme des enfants de init (0 = ppid) pendant de longues périodes (secondes), alors quelque chose est probablement faux.

– Quelqu’un peut-il écrire du code C pour créer un zombie dont le parent est Init?

Ce n’est pas clair, mais je pense que vous voulez:

 pid_t f = fork(); if (f > 0) { exit(0); // this is the parent dying, so the child will be an orphan // and get adopted by init } else if (f == 0) { sleep(100); // This is the child doing something that takes enough time for // its parent to commit suicide (exit(0)) and then for you to // observe that it has now been adopted by init exit(0); // And now it dyes as well, so init should reap its status, but // it may be a zombie for a short amount of time first. } else /* error condition would be handled here */ 

– Les zombies peuvent-ils refuser de libérer de la mémoire?

Les zombies ne peuvent rien retenir. Ils perdent toutes leurs pages de mémoire, leurs poignées de fichier ouvertes, etc. A peu près tout ce que le système d’exploitation peut trouver pour se libérer devrait être libéré. Ce serait un bug de ne pas le faire, mais rappelez-vous que le système d’exploitation doit savoir que c’est quelque chose qui est censé être libéré. Il est très facile de créer des ressources dans l’espace utilisateur qui doivent être libérées lorsqu’un programme meurt que le système d’exploitation ne connaît pas est censé être libéré.

Un processus zombie est purement une valeur de statut pid et de sortie. Le pid ne peut pas être libéré car la ressource (le pid) “appartient” au parent. Si elle était libérée, un autre processus pourrait se voir atsortingbuer le même identifiant, et le parent pourrait alors envoyer des signaux à un processus indépendant. même si le parent attendait en premier pour déterminer si l’enfant était sorti, il n’y aurait aucun moyen d’éviter les conditions de course.

Si vous souhaitez voir le processus zombie dans une liste de processus en cours, utilisez ceci:

 #include  #include  #include  int main(void) { pid_t p = fork(); // creates child process and stores the returned PID if (p != 0) // executed by parent process { sleep(1); /* the child process terminates while the parent process sleeps, the child then becomes a zombie process because the returned status of the terminated child process isn't checked via a wait() */ system("ps -eo pid,ppid,stat,cmd"); // prints a list of processes in your terminal } else // executed by child process { exit(0); // the child process terminates immediately } return 0; } 

Vous pouvez identifier le processus zombie par le Z + dans la liste:

REMARQUE: vous devrez modifier le code si vous utilisez Windows.