Zombie-Prozesse

-- was sind die Vorteile des Zombie-Prozesskonzepts?

Ein Zombie-Prozess ist nur eine PID, ein Exit-Status und einige Buchhaltungsinformationen, die herumliegen, bis ein Elternteil einen der wait verwendet Familie von Systemaufrufen, um ihren endgültigen Status zu erhalten. Bis ein Elternteil wait anruft Die Prozess-ID des untergeordneten Prozesses muss als verwendet markiert bleiben, damit ihr kein anderer Prozess zugewiesen werden kann. Wenn einem anderen Prozess eine recycelte PID zugewiesen würde, wäre es schwierig, den Unterschied zwischen ihm und früheren Prozessen zu erkennen, die dieselbe PID hatten. Einmal wait vom Elternteil aufgerufen wird und einen endgültigen Exit-Status zurückgibt, kann davon ausgegangen werden, dass niemand mehr nach dem Kind bei dieser PID suchen wird, sodass die PID jetzt wiederverwendet werden kann. (Ich denke, unter Linux, wenn ein Elternteil SIGCHLD als SIG_IGN verlässt Kernel wird keine Zombies in der Nähe halten, aber dass die Neuregistrierung von SIGCHLDs Disposition als SIG_IGN nicht den gleichen Effekt hat)

-- wissen, dass der Kernel (PID, Beendigungsstatus, Ressourcennutzungsinformationen) für Zombie-Prozesse speichert, was die Bedeutung von "Ressourcennutzungsinformationen" ist

Einige dieser Informationen beziehen sich auf das Ausführen eines Programms als:

time my_program

werde melden. Diese Werte werden normalerweise in der siginfo-Struktur für SIGCHLD gemeldet (was nicht gerade ein Aufruf von wait ist ), sondern auch über einen Anruf an waitid verfügbar Form des Systemaufrufs (auf einigen Systemen). Sehen Sie sich man sigaction an für Informationen über diese Struktur.

-- wie zombie's PPID() =1 und es immer noch zombie , (init erntet Zombies, weil es standardmäßig wait() hat)

Ein Zombie, dessen ppid =1 ist, sollte nicht sehr lange ein Zombie bleiben, weil init sollte es ziemlich schnell ernten. Ein Prozess bleibt ein Zombie ab einem Punkt kurz nachdem er stirbt (entweder über exit oder durch ein nicht übergebenes Signal, das es tötet), bis sein Elternteil wait ruft und erhält seinen endgültigen Status. Das bedeutet, dass selbst wenn init nichts anderes tut, als init immer wieder aufzurufen, es eine kleine Zeitspanne geben kann, in der ein Prozess als Zombie auftauchen kann. Wenn Prozesse als untergeordnete Elemente von init angezeigt werden (0=ppid) für längere Zeit (Sekunden), dann stimmt wahrscheinlich etwas nicht.

-- kann irgendjemand einen C-Code schreiben, um einen Zombie dazu zu bringen, dass sein Elternteil Init ist?

Das ist nicht klar, aber ich denke, Sie wollen:

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 dies 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 */

-- können sich Zombies weigern, eine Speichersperre freizugeben??

Zombies können nicht viel von irgendetwas festhalten. Sie verlieren alle ihre Speicherseiten, geöffnete Dateihandles usw. So ziemlich alles, was das Betriebssystem herausfinden kann, wie es freigegeben werden kann, sollte freigegeben werden. Es wäre ein Fehler, dies nicht zu tun, aber denken Sie daran, dass das Betriebssystem wissen muss, dass es etwas ist, das befreit werden soll. Es ist sehr einfach, Ressourcen im Benutzerbereich zu erstellen, die freigegeben werden sollten, wenn ein Programm stirbt, von dem das Betriebssystem nicht weiß, dass sie freigegeben werden sollen.

Ein Zombie-Prozess ist lediglich ein PID- und Exit-Statuswert. Die PID kann nicht freigegeben werden, da die Ressource (die PID) dem übergeordneten Element "gehört". Wenn es freigegeben würde, könnte einem anderen Prozess dieselbe PID zugewiesen werden, und dann könnte der übergeordnete Prozess am Ende Signale an einen nicht verwandten Prozess senden; Selbst wenn der Elternteil erst abwarten würde, ob das Kind ausgestiegen ist, gäbe es keine Möglichkeit, Race Conditions zu vermeiden.

Wenn Sie daran interessiert sind, den Zombie-Prozess in einer Liste der laufenden Prozesse zu sehen, verwenden Sie Folgendes:

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

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;
}

Sie erkennen den Zombie-Prozess an dem Z+ in der Liste:

HINWEIS:Sie müssen den Code ändern, wenn Sie Windows verwenden.