Zombie-Prozess vs. Orphan-Prozess

Ein Zombie wird erstellt, wenn ein übergeordneter Prozess den Wait-Systemaufruf nicht verwendet, nachdem ein untergeordneter Prozess gestorben ist, um seinen Beendigungsstatus zu lesen, und ein Waisenkind ein untergeordneter Prozess ist, der von init zurückgefordert wird, wenn der ursprüngliche übergeordnete Prozess vor dem untergeordneten Prozess beendet wird.

Wie werden diese Prozesse in Bezug auf die Speicherverwaltung und die Prozesstabelle anders behandelt, insbesondere in UNIX?

Was ist ein Beispiel oder Extremfall, wenn die Erschaffung von Zombies oder Waisen der größeren Anwendung oder dem System abträglich sein kann?

Wenn ein Kind austritt, muss ein Prozess ausgeführt werden wait darauf, um seinen Exit-Code zu erhalten. Dieser Beendigungscode wird in der Prozesstabelle gespeichert, bis dies geschieht. Der Vorgang des Lesens dieses Exit-Codes wird als “Ernten” des Kindes bezeichnet. Zwischen der Zeit, in der ein Kind austritt und geerntet wird, wird es als Zombie bezeichnet. (Die ganze Nomenklatur ist ein bisschen grausam, wenn man darüber nachdenkt; ich empfehle, nicht zu viel darüber nachzudenken.)

Zombies nehmen nur Platz in der Prozesstabelle ein. Sie nehmen keinen Speicher oder CPU. Die Prozesstabelle ist jedoch eine endliche Ressource, und viele Zombies können sie füllen, was bedeutet, dass keine anderen Prozesse gestartet werden können. Darüber hinaus sind sie lästiges Durcheinander und sollten dringend vermieden werden.

Wenn ein Prozess mit noch laufenden Kindern beendet wird (und seine Kinder nicht tötet; die Metapher bleibt bizarr), sind diese Kinder Waisen. Waisenkinder werden sofort von ihnen „adoptiert“. init (Eigentlich denke ich, dass die meisten Leute dies “Neubeeltern” nennen, aber “Adoption” scheint die Metapher besser zu tragen). Ein Waisenkind ist nur ein Prozess. Es wird alle Ressourcen verwenden, die es verwendet. Es ist vernünftig zu sagen, dass es überhaupt kein “Waisenkind” ist, da es einen Elternteil hat, aber ich habe sie oft so genannt gehört.

init erntet automatisch seine Kinder (adoptiert oder nicht). Wenn Sie also aussteigen, ohne Ihre Kinder aufzuräumen, werden sie nicht zu Zombies (zumindest nicht länger als einen Moment).

Aber es gibt langlebige Zombies. Was sind Sie? Sie sind die ehemaligen Kinder eines bestehenden Prozesses, der sie nicht geerntet hat. Der Prozess kann hängen bleiben. Oder es ist schlecht geschrieben und vergisst, seine Kinder zu ernten. Oder vielleicht ist es überlastet und hat es nicht geschafft. Oder Wasauchimmer. Aber aus irgendeinem Grund existiert der übergeordnete Prozess weiter (also sind sie keine Waisen), und es wurde nicht auf sie gewartet, sodass sie als Zombies in der Prozesstabelle weiterleben.

Wenn Sie also Zombies länger als einen Moment sehen, bedeutet dies, dass mit dem übergeordneten Prozess etwas nicht stimmt und dass etwas getan werden sollte, um dieses Programm zu verbessern.

Wenn ein Prozess beendet wird, werden seine Ressourcen vom Betriebssystem freigegeben. Sein Eintrag in der Prozesstabelle muss jedoch dort bleiben, bis der Elternprozess wait() aufruft, da die Prozesstabelle den Exit-Status des Prozesses enthält. Ein Prozess, der beendet wurde, dessen Elternprozess aber noch nicht wait() aufgerufen hat, wird als a bezeichnet Zombie-Prozess. Alle Prozesse gehen in diesen Zustand über, wenn sie beendet werden, aber im Allgemeinen existieren sie nur kurz als Zombies. Sobald der Elternprozess wait() aufruft, werden die Prozesskennung des Zombie-Prozesses und sein Eintrag in der Prozesstabelle freigegeben.

Überlegen Sie nun, was passieren würde, wenn ein Elternteil wait() nicht aufruft und stattdessen beendet wird, wodurch seine Kindprozesse als verbleiben Waisen. Linux und UNIX gehen dieses Szenario an, indem sie verwaisten Prozessen den Init-Prozess als neuen Elternprozess zuweisen. Der Init-Prozess ruft in regelmäßigen Abständen wait() auf, wodurch der Exit-Status jedes verwaisten Prozesses erfasst werden kann und die Prozesskennung und der Prozesstabelleneintrag des verwaisten Prozesses freigegeben werden.

Quelle: Betriebssystemkonzepte durch Abraham, Petrus, Gregor

Ein verwaister Prozess ist ein Computerprozess, dessen parent process beendet oder beendet wurde, obwohl er (untergeordneter Prozess) selbst weiter läuft.
EIN Zombie-Prozess oder nicht mehr existierender Prozess ist ein Prozess, der die Ausführung abgeschlossen hat, aber immer noch einen Eintrag in der Prozesstabelle hat, da sein übergeordneter Prozess keinen aufgerufen hat wait() Systemaufruf.

Orphan – Eltern-Exit, Init-Prozess wird zum Elternprozess des Kindprozesses. Immer wenn child beendet wird, wird die Prozesstabelle von os gelöscht.

Zombie – Wenn das Kind beendet, gibt es dem Elternteil den Exit-Status. Angenommen, Ihr Elternteil befindet sich im Schlafzustand und kann keinen Status vom Kind erhalten. Obwohl der untergeordnete Exit, aber der Prozess Platz in der Prozesstabelle belegt

Sehen Sie sich diesen Befehl in Linux Ubuntu an >>ps -eo pid,ppid,status,cmd

Wenn Sie am Ende so etwas wie Defunc gefunden haben, ist Ihr Prozess Zombie und belegt Platz.

Zombie-Prozess:
Ein Prozess, der die Ausführung beendet hat, aber noch einen Eintrag in der Prozesstabelle hat, um ihn an seinen übergeordneten Prozess zu melden, wird als Zombie-Prozess bezeichnet. Ein untergeordneter Prozess wird immer zuerst zum Zombie, bevor er aus der Prozesstabelle entfernt wird. Der Elternprozess liest den Austrittsstatus des Kindprozesses, der den Eintrag des Kindprozesses aus der Prozesstabelle ableitet.

Waisenprozess:
Ein Prozess, dessen Elternprozess nicht mehr existiert, dh entweder beendet oder beendet wurde, ohne auf die Beendigung seines Kindprozesses zu warten, wird als verwaister Prozess bezeichnet.

1. Es gibt keine Waisen außer dem Prozess, der PID 1 verwendet.

   Aus Sicht des laufenden Prozesses macht es keinen Unterschied, ob er direkt gestartet wurde und daher PID 1 als Elternteil hat oder von PID 1 geerbt wurde, weil sein ursprünglicher Elternteil (der sich von PID 1 unterscheidet) beendet wurde. Es wird wie jeder andere Prozess behandelt.

2. Jeder Prozess durchläuft am Ende eine Art Zombie-Zustand, nämlich die Phase zwischen der Ankündigung seines Endes durch Ausgabe SIGCHLD und deren Verarbeitung (Zustellung oder Unwissenheit) bestätigt wird.

Wenn der Zombie-Zustand erreicht wurde, ist der Prozess nur ein Eintrag in der Prozessliste des Systems.

Die einzige bedeutende Ressource, die ein Zombie ausschließlich verwendet, ist eine gültige PID.

Ich möchte 2 Codeschnipsel hinzufügen, die einen Waisen- und einen Zombie-Prozess enthalten. Aber zuerst werde ich die Definition dieser Prozesse posten, wie sie im Buch “Operating System Concepts” von Silberschatz, Galvin und Gagn angegeben ist:

Wenn kein übergeordneter wartender Prozess (hat wait() nicht aufgerufen) ein Prozess ist Zombie

Wenn der Elternteil ohne Aufrufen von wait beendet wird, ist der Prozess ein verwaist

Verwaist

// A C program to demonstrate Orphan Process.  
// Parent process finishes execution while the 
// child process is running. The child process 
// becomes orphan. 

#include <stdio.h>  //printf
#include <stdlib.h> //exit
#include <sys/types.h> //fork
#include <unistd.h> //fork and sleep
  
int main() 
{ 
    // Fork returns process id 
    // in parent process 
    pid_t child_pid = fork(); 
  
    // Parent process didn't use wait and finished before child
    // so the child becomes an orphan process

    // Parent process 
    if (child_pid > 0) {
        printf("I finished my execution before my child"); 
    }
    else // Child process 
        if (child_pid == 0) { 
            sleep(1); //sleep for 1 second
            printf("This printf will not be executed"); 
        } 
        else{
            //error occurred
        }
  
    return 0; 
}

Ausgabe

Ich beendete meine Hinrichtung vor meinem Kind

Zombie

// A C program to demonstrate Zombie Process. 
// Child becomes Zombie as parent is not waiting
// when child process exits. 

#include <stdio.h>  //printf
#include <stdlib.h> //exit
#include <sys/types.h> //fork
#include <unistd.h> //fork and sleep

int main() 
{ 
    // Fork returns process id 
    // in parent process 
    pid_t child_pid = fork(); 
 
    // Parent process didn't use wait 
    // so the child becomes a zombie process

    // Parent process 
    if (child_pid > 0){ 
        sleep(1); //sleep for 1 second
        printf("\nI don't wait for my child");
    }
    else // Child process 
        if(child_pid == 0){ 
            printf("My parent doesn't wait me");
            exit(0);
        }
        else{
            //error occurred
        }
    
    return 0; 
} 

Ausgabe

Meine Eltern warten nicht auf mich

Ich warte nicht auf mein Kind

Edit: Quelle und Inspiration entnommen aus hier