23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

SISTEMAS
OPERATIVOS

9 N OV I E M B R E , 2 0 1 6 / C / P U B L I C A R U N C O M E N TA R I O

Procesos Zombies y Huérfanos

 PDF

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 1/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

Zombies y Huérfanos

Cuando un proceso muere en linux, no se elimina completamente de la memoria. Su

descriptor de proceso permanece en memoria (ocupa muy poco). El estado del proceso que
muere pasa a ser EXIT_ZOMBIE y el proceso padre es noti cado mediante la señal
SIGCHLD que el proceso hijo ha muerto.

Se supone que el proceso padre ejecuta la llamada al sistema wait() para poder leer el
estado de terminación del proceso hijo y otra información. Esto permite al proceso padre
obtener información del hijo muerto. Después de la wait(), el proceso zombie es eliminado
completamente de la memoria.

Esto ocurre muy rápido y por tanto no vemos procesos zombies acumulados en el sistema.
Sin embargo, si el proceso padre no está bien programado y no llama a wait(), su hijo
zombie se quedará en ese estado usando memoria del sistema que no será eliminada hasta
que el padre muera.

Por tanto en el supuesto que el padre continúe su ejecución y los hijos vayan terminando
sin que el padre capture la señal SIGCHLD (en cuyo manejador estaría la llamada a wait() )
o bien en su código se ejecute wait() en algún momento, a la espera de la terminación de
sus hijos, entonces conforme los procesos hijos van terminando van convirtiéndose en
zombies.

Cuando el padre muere antes de que los procesos hijos acaben, estos pasan a ser huerfanos
(que no zombie), y son heredados por el proceso init que es el proceso padre de todos los
procesos. El proceso init tiene el PID = 1. El proceso init ejecuta periódicamente wait()para
que todos los hijos huérfanos heredados puedan eliminarse del sistema.

En el ejercicio c027.c

1 #include <stdio.h>
2 #include <unistd.h>
3 int main(void) {
4 printf("Parent PID=%d\n",getpid() );
5 if (fork()==0) {
6 printf ("PPID=%d\n",getppid() );
7 return 0;
8 }
9 return 0;
10 }

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 2/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

El proceso hijo pregunta por el pid de su padre con getppid() y termina. El proceso padre,
antes de crear al hijo muestra su pid con getpid(). En la salida, ambos deben de coincidir si
el padre no termina antes que su hijo. Si terminase antes que el hijo, el hijo pasaría a ser
huérfano y heredado por init, en cuyo caso mostraría el pid 1 (el de su nuevo padre). En
función de la carga del sistema, la plani cación etc… puede darse el caso, pero
normalmente el hijo ejecuta la llamada a getppid() antes de que el padre acabe.

En el ejercicio c028.c …

1 #include <stdio.h>
2 #include <unistd.h>
3 int main(void) {
4 printf("Parent PID=%d\n",getpid() );
5 if (fork()==0) {
6 sleep (2);
7 printf ("PPID=%d\n",getppid() );
8 return 0;
9 }
10 return 0;
11 }

… forzamos que el hijo duerma unos 2 segundos, tiempo su ciente para que el padre
termine y el hijo quede huérfano, siendo por tanto heredado por init. Cuando el hijo
despierta muestra el pid de su padre que ahora es 1 y termina quedando zombie. El proceso
init será ahora el encargado de ejecutar su wait() para la terminación y eliminación del
hijo.

Esto se resuelve parcialmente en el programa c029.c …

1 #include <stdio.h>
2 #include <unistd.h>
3 int main(void) {
4 printf("Parent PID=%d\n",getpid() );
5 if (fork()==0) {
6 printf ("PPID=%d\n",getppid() );
7 return 0;
8 }
9 sleep (2);
10 return 0;
11 }

… donde el padre es el que espera los 2 segundos, tiempo su ciente para que el hijo ejecute
su llamada a getppid() antes de convertirse en huérfano.

¿Que pasa si el hijo huérfano se quedara en un bucle y no terminara?

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 3/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

Problemas con los procesos zombies

Para ver los procesos zombies que se van quedando en el sistema podemos usar la orden
top, ps o bien el Gestor de Tareas. La orden top nos indica en la cabecera cuantos procesos
zombies hay. Con ps y el Gestor de Tareas podremos ver el estado de los procesos, que
cuando son zombies su estado es Z.

Los procesos zombis no usan recursos del sistema, puesto que cuando mueren el S.O.
libera todos los recursos asociados a éstos y elimina la memoria ocupada por el proceso,
pero deja el descriptor de proceso y el pid sigue asignado al proceso zombie. Puesto que
cada zombie mantiene su pid y el número de procesos distintos es limintado (en un
sistema de 32 bits sólo pueden ser 32767 pids distintos). Si los zombies se acumulan
muchos y muy rápido podemos poner al sistema en situación de no poder crear más
procesos puesto que no quedan pids disponibles para ser asignados a los nuevos procesos.

Sin embargo, tener unos cuantos zombies en un momento dado no es problema, puesto
que suponemos que llegarán a ser huérfanos en algún momento e init acabará con ellos.
Incluso en el caso en que no, tampoco sería dramático, pero hay que observarlo.

Acabar con los procesos zombies.

No se pueden matar los procesos zombies de la misma forma que puedes matar (con kill)
los procesos normales, ya que los procesos zombies ya están muertos. No es necesario
eliminar los procesos zombies del sistema a menos que tengas muchos de ellos y
continuamente, algún programa mal diseñado esté creando y dejando en bucle o sin
terminar, procesos zombies.

En ese caso deberíamos identi car el proceso mal diseñado y corregir el error. Pero
tendremos que matar a los procesos zombies, no obstante. Tener en cuenta que el proceso
zombie, lo es porque ha muerto y su padre no ha recogido su estado de terminación con
wait(), por lo que el hijo zombie, sigue siendo hijo del proceso padre.

Si a un padre le enviamos (como root o como el propietario del proceso) una señal
SIGCHLD, este debería lanzar el manejador de la señal donde respondería con una llamada
a wait() para liberar al hijo. Pero estamos en el supuesto de que esto no pasa, precisamente

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 4/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

por eso se están quedando los hijos zombies. Entonces, no nos queda más remedio que
matar al proceso padre que está generando esa gran cantidad zombies.

En el momento que el padre muere, todos los zombies, son a su vez huerfanos, siendo
heredados por init, que llamará periódicamente a wait() para garantizar la eliminación de
los procesos de memoria.

← ENTRADA ANTERIOR SIGUIENTE ENTRADA →

Backup de tus datos Esqueleto Práctica Parte Bash

Miguel Onofre Martínez Rach

TAMBIÉN TE PUEDE GUSTAR

Man pages, Encontrando

ayuda
Destruir un semáforo 2 octubre, 2017
5 enero, 2019
Sincronización Padre-Hijos
con semáforos y memoria
compartida
13 diciembre, 2016

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 5/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

DEJA UN COMENTARIO

Conectado como alu34. ¿Quieres salir?

Comentario

P U B L I C A R C O M E N TA R I O

Buscar

CONTENIDO

Blog (49)
Sistemas Operativos (8)

Bash (13)
Ejercicios (7)
Ejercicios Memoria (6)

Ejercicios Procesos (1)

C (11)

Práctica (7)

Mapa del Blog

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 6/7
23/1/2019 Procesos Zombies y Huérfanos – Sistemas Operativos

ENTRADAS RECIENTES

Destruir un semáforo
5 enero, 2019

Ejercicio Memoria 06
17 diciembre, 2018

Evaluación
17 septiembre, 2018

COMENTARIOS RECIENTES

Miguel Onofre Martínez Rach en Ejercicio Memoria 01

DANIEL GONZALEZ SANCHEZ en Ejercicio Memoria 01

2019 © Sistemas Operativos. Creado con cariño por SiteOrigin.

http://so.momrach.es/procesos-zombies-y-huerfanos-ejercicios-c027-a-c029/ 7/7