Zombie (EDV)

Ein Zombie ist vor allem in Unix-ähnlichen Betriebssystemen (wie beispielsweise Linux) ein Prozess, der beendet ist, aber trotzdem noch in der Prozesstabelle auftaucht und geringfügig Systemressourcen belegt. Ein Zombie richtet selbst keinen Schaden an, kann aber auf einen Fehler hinweisen.

Entstehung von Zombieprozessen

Wenn ein Prozess einen neuen Prozess startet (mittels Verzweigung), wird der alte Elternprozess, und der neue Kindprozess genannt. Wenn der Kindprozess beendet wird, kann der Elternprozess vom Betriebssystem erfragen, auf welche Art der Kindprozess beendet wurde: erfolgreich, mit Fehler, abgestürzt, abgebrochen, etc.

Um diese Abfrage zu ermöglichen, bleibt ein Prozess, selbst nachdem er beendet wurde, in der Prozesstabelle stehen, bis der Elternprozess diese Abfrage durchführt – egal ob diese Information gebraucht wird oder nicht. Bis dahin hat der Kindprozess den Zustand Zombie. In diesem Zustand belegt der Prozess selbst keinen Arbeitsspeicher mehr (bis auf den platzmäßig vernachlässigbaren Eintrag in der Prozesstabelle des Kernels) und verbraucht auch keine Rechenzeit, jedoch behält er seine PID, die (noch) nicht für andere Prozesse wieder verwendet werden kann.

Der Kernel sendet an den Elternprozess ein spezielles Signal, nämlich SIGCHLD, sobald eines seiner Kinder beendet wird. Im Handler für dieses Signal ist die Statusabfrage des Kindprozesses durchzuführen, damit er endgültig verschwindet. Geschieht dies nicht oder wird überhaupt kein Handler für SIGCHLD angegeben (in diesem Fall wird das Signal einfach ignoriert), verbleibt das Kind im Zombie-Zustand in der Prozesstabelle.

Verwaiste Prozesse

Ein weiterer Spezialfall, der an und für sich unabhängig von Zombies ist, jedoch in Kombination damit auftreten kann, ist, wenn der Elternprozess beendet wird. In diesem Fall werden alle seine Kindprozesse „verwaist“ genannt. Die Kindprozesse werden dann per Definition vom Prozess mit der PID 1 „adoptiert“ und bekommen diesen als Vaterprozess zugewiesen. (In der klassischen System-V-Bootfolge, die auch heute noch von den meisten Linux-Distributionen verwendet wird, hat der sogenannte init-Prozess die PID 1. Bei OS X tritt launchd an diese Stelle.) Dies passiert wohlgemerkt für laufende genauso wie für Zombieprozesse, deren Eltern nicht mehr existieren.

Probleme von Zombies

Zombies stellen in der Regel kein Problem für ein Betriebssystem dar, da diese Prozesse bereits beendet wurden und nur sehr wenige Systemressourcen in Anspruch nehmen. Allerdings kann der verursachende Fehler im Vaterprozess unter Umständen, wie beispielsweise bei hoher Belastung, weit größere Folgen haben. Eine große Anzahl von Zombies kann auch dazu führen, dass dem Kernel die freien PIDs, die er für neue Prozesse braucht, ausgehen. Die PID-Belegung durch Zombies ist unter Umständen problematischer als deren minimaler Speicherverbrauch.

Behandlung von Zombieprozessen

Obwohl Zombieprozesse in der Regel keine Gefahr für das System darstellen, können sie dennoch manuell gelöscht werden – oder auch automatisiert vom System.

Automatisiertes Löschen

Der init-Prozess hat unter anderem die Aufgabe, den Beendigungszustand aller seiner Kinder abzufragen, sobald diese beendet – also in den Zombie-Zustand überführt – werden. Damit sorgt er dafür, dass keine überflüssigen Zombies im System vorhanden sind. Laufende Prozesse, die vom init-Prozess adoptiert werden, werden dadurch nicht beeinträchtigt – wartet der init-Prozess einfach, bis sie fertig sind, und fragt anschließend deren Status ab.

Manuelles Löschen

Ein Zombieprozess kann in der Unix-Prozesstabelle in der Regel durch den Status „Z“ (für Zombie) erkannt werden (zum Beispiel mit ps axo stat,pid,comm | grep '^Z'). Durch das kill-Kommando kann das Signal SIGKILL an die PID des Zombieprozesses gesendet werden, um diesen zwanghaft aus der Prozesstabelle zu löschen. Es kann bei dieser Methode jedoch zu unvorhergesehenen Seiteneffekten kommen, falls der Vaterprozess noch läuft und zu einem späteren Zeitpunkt auf den Status seines Kindprozesses zugreifen möchte.

Alternativ kann man dem Vaterprozess des Zombies (laut PPID-Angabe in der Prozesstabelle, zum Beispiel von ps axo stat,pid,comm,ppid | grep '^Z') manuell das Signal SIGCHLD senden, auf der Kommandozeile etwa mittels kill -CHLD <PID des Vaterprozesses> . Reagiert der Vater darauf nicht, so kann man den Vaterprozess beenden, damit das Zombie-Kind vom init-Prozess adoptiert und sofort danach durch Abfrage seines Zustands endgültig gelöscht wird.

Besonderheit im Linux-Kernel

Der Linux-Kernel bietet für Prozesse, die nicht am Status ihrer Kinder interessiert sind, eine einfache – wohlgemerkt nicht standardisierte – Methode, Zombies loszuwerden: Gibt ein Prozess explizit an, dass er SIGCHLD ignorieren will (im Gegensatz zum Ignorieren per Default, wenn kein Handler angegeben ist), so löscht Linux die Zombies automatisch, ohne auf eine Statusabfrage zu warten.

Programmierfehler beseitigen

Wenn ein Prozess seine Kinder oftmals „vergisst“ und zu Zombies werden lässt, besonders wenn er auch auf ein manuelles SIGCHLD nicht reagiert, ist das meistens ein Hinweis auf einen Bug in diesem Programm. Aus oben genannten Gründen sollten diese Fehler im Programm beseitigt werden, um das System durch die entstehenden Zombies nicht zu beeinträchtigen.

Beispiel in C zur Erzeugung von Zombies

Synchrones Warten auf den selben Kindprozess in einer fest definierten Reihenfolge kann Zombieprozesse erzeugen und diese sogar über eine lange Zeit am Leben erhalten. Dies ist nicht notwendigerweise ein Programmierfehler, wie im Folgenden Codebeispiel zu sehen ist:

#include <sys/wait.h>
#include <stdlib.h>
#include <unistd.h>
 
int main(void){
    pid_t pids[10]; // Platz für 10 Prozess-IDs (die Kindprozesse)
    int i; // Laufvariable
 
    for (i = 0; i < 10; ++i) {
        // Der Vaterprozess erzeugt nun einen Kindprozess,
        // welcher unabhängig vom Vaterprozess mit der
        // erneuten Ausführung des Programms beginnt.
        // Ein Kindprozess erzeugt keinen Fork von sich selbst.
        pids[i] = fork();
        if (pids[i] == 0) {
            // dann befinden wir uns in einem der 10 Kindprozesse
            // Der erste Kindprozess wartet 10 Sekunden und jeder
            // weitere Kindprozess wartet 1 Sekunde kürzer als der
            // vorige.
            sleep(10-i);
            exit(0); // Kindprozess erfolgreich beenden
        }
    }
 
    // hier kommt nur der Vaterprozess vorbei
    for (i = 0; i < 10; ++i){
        // Der Vaterprozess wartet nun, bis der Reihe nach jeder
        // seiner 10 Kindprozesse beendet ist. Leider wird auf das
        // Kind mit der längsten Wartezeit zuerst gewartet. Obwohl
        // die anderen Kinder längst erfolgreich beendet wurden,
        // blockiert das erste Kind eine Bereinigung der Prozesstabelle
        waitpid(pids[i], NULL, 0);
    }
 
    return 0; // Vaterprozess erfolgreich beenden
}

Dennoch ist das Verhalten nicht optimal. Eine bessere Alternative bestünde darin, auf einen beliebigen Prozeß zu warten, ihn im Array als erledigt zu markieren und diesen Prozeß fortzuführen, bis das Array leer ist.