Warum zombie-Prozesse existieren?

Wikipedia sagt: "Ein Kind-Prozess, der beendet ist, aber noch nie gewartet, auf durch seine Eltern wird ein zombie-Prozess." Ich dieses Programm ausführen:

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
int main()
{
    pid_t pid, ppid;
    printf("Hello World1\n");
    pid=fork();
    if(pid==0)
    {
        exit(0);    
    }
    else
    {
        while(1)
        {
        printf("I am the parent\n");
        printf("The PID of parent is %d\n",getpid());
        printf("The PID of parent of parent is %d\n",getppid());        
        sleep(2);
        }
    }
}

Dieser erstellt einen zombie-Prozess, aber ich kann nicht verstehen, warum ein zombie-Prozess ist hier angelegt?

Die Ausgabe des Programms ist

Hello World1
I am the parent
The PID of parent is 3267
The PID of parent of parent is 2456
I am the parent
The PID of parent is 3267
The PID of parent of parent is 2456
I am the parent
....
.....

Aber warum ist es, dass die "Kind-Prozess beendet wird, aber nicht gewartet auf durch seine Eltern" in diesem Fall?

Sind Sie Fragen, warum das Konzept einer zombie-Prozess eingeführt wurde, in Unix? Wie es aussieht, die einzige Antwort auf Ihre Frage, die ich sehe, ist "weil das ist, wie zombie-Prozesse sind definiert".
"konnte nicht verstehen, warum zombie-Prozess erstellt werden, hier" werden würden, weil Sie nicht aufrufen wait() zu Lesen, das Kind der exit-status, und damit auch deren Eintrag hinterlassen wird, in der Prozess-Tabelle.
Das ist ok. Aber wenn Kind läuft seit einiger Zeit existiert und es gibt keine zombie
Ja, zombies sind lebende tote. Zombie-Prozesse sind gestorben (entweder von einem signal oder weil Sie verlassen haben), und der übergeordnete Prozess hat noch nicht ausgeführt, eine wait() für den Prozess. Der zombie ist tot, aber immer noch nimmt eine Prozess-Tabelle slot und wird dies auch weiterhin tun, bis seine Eltern wartet, bis es oder der allein sorgeberechtigte Elternteil wird beendet. Wenn der parent beendet wird, wird das Kind vererbt werden, die durch die init Prozess (in der Regel PID 1), und eines der Hauptziele dieses Prozesses (wenn nicht der einzige), ist zu warten, bis die Kinder sterben.
Der Kind-Prozess führt die exit(0); damit beendet. Der parent-Prozess in eine unendliche Schleife ohne zu warten, für Ihr Kind zu sterben. In diesem Zusammenhang warten bedeutet 'Aufruf einer der Funktionen wait() oder waitpid() oder eine der verschiedenen system-abhängigen alternativen wie wait3() oder wait4()'. Es bedeutet nicht nur 'der Eltern geht auf Leben'. Wenn das Kind nicht sterben, es ist nicht möglich zombie-Prozess; zombie-Prozesse sind tot.

InformationsquelleAutor user567879 | 2013-04-18

  1. 26

    In Ihrem code, den zombie, der erstellt wird, auf exit(0) (Kommentar mit Pfeil unten):

    pid=fork();
if (pid==0) {
    exit(0);  //<--- zombie is created on here
} else {
    //some parent code ...
}

    Warum? Weil Sie nie waited. Wenn etwas fordert waitpid(pid) ist, gibt es post-mortem-Informationen über den Prozess, wie seine exit-code. Leider, wenn der Prozess beendet wird, der kernel kann nicht einfach entsorgen dieses Prozesses Eingabe oder return-code verloren. So wartet er auf jemanden, der wait auf, und verlässt diesen Prozess Eintrag um, auch wenn es nicht wirklich belegen keinen Speicher, außer für die Einreise in die Prozess-Tabelle - dies ist genau das, was ist genannt zombie.

    Haben Sie wenige Optionen, um zu vermeiden, zombies:

    1. Hinzufügen waitpid() irgendwo in der parent-Prozess. Zum Beispiel damit:

      pid=fork();
if (pid==0) {
    exit(0);    
} else {
    waitpid(pid);  //<--- this call reaps zombie
    //some parent code ...
}

    2. Führen Doppel - fork() zu erhalten Enkel und beenden in Kind während der Enkel ist noch am Leben. Enkel werden dann automatisch angenommen init wenn Ihre Eltern (unser Kind) stirbt, das bedeutet, wenn ein Enkelkind stirbt, wird es automatisch waited auf durch init. In anderen Worten, müssen Sie etwas tun, wie dieses:

      pid=fork();
if (pid==0) {
    //child
    if (fork()==0) {
        //grandchild
        sleep(1); //sleep a bit to let child die first
        exit(0);  //grandchild exits, no zombie (adopted by init)
    }
    exit(0);      //child dies first
} else {
     waitpid(pid);  //still need to wait on child to avoid it zombified
     //some parent code ...
}

    3. Explizit ignorieren SIGCHLD-signal im übergeordneten. Wenn Kind stirbt, die Eltern geschickt bekommt SIGCHLD signal können die es reagieren auf Kinder Tod. Sie können rufen Sie waitpid() nach Erhalt dieses Signals, oder Sie können installieren ausdrückliche ignorieren der signal handler (mit signal() oder sigaction()), die machen sicher, dass das Kind nicht zum zombie. In anderen Worten, so etwas wie dieses:

      signal(SIGCHLD, SIG_IGN); //<-- ignore child fate, don't let it become zombie
pid=fork();
if (pid==0) {
    exit(0); //<--- zombie should NOT be created here
} else {
     //some parent code ...
}
    Warum ignorieren SIGCHLD-signal töten Sie den zombie? Ich verstehe, dass es macht Sie sicher, dass der Kind-Prozess nicht zu einem zombie. Also die nicht-zombie-Prozess wird beendet, sobald das Programm beendet wird? Und ein zombie-Prozess wird nicht aufhören, sobald ein Programm beendet wird?
    Wieder zombie nicht getötet werden dürfen: das bereits tot ist, was bleibt, ist der Eintrag in der kernel-Prozess-Tabelle. SIGCHLD ignorieren können kernel weiß, dass es ok ist, zu entsorgen, dass der Eintrag sofort.

    InformationsquelleAutor mvp

Schreibe einen Kommentar