Al monitorear un sistema Linux con el comando top, a veces puedes encontrar una entrada como 1 zombie en la línea de 'Tareas (Tasks)'.

top - 16:03:19 up 7:09, 1 usuario, load average: 2.24, 2.21, 2.29
Tareas: 392 total, 1 ejecutando, 390 esperando, 0 detenidos, 1 zombie
...

¿Qué es este 'zombie' y qué impacto tiene en el sistema? En este artículo, explicaremos con claridad la identidad de los procesos zombie y cómo identificarlos y resolverlos.

¿Qué es un Proceso Zombie? 🧟

Para facilitar la comprensión, hagamos una analogía con el ciclo de vida de un proceso.

  1. Nacimiento (Fork): El proceso padre (Parent Process) crea un proceso hijo (Child Process) (fork()).

  2. Ejecutar (Exec): El proceso hijo lleva a cabo su trabajo.

  3. Terminar (Exit): El proceso hijo completa su tarea y termina (exit()).

  4. Cosechar (Wait): Cuando el proceso hijo termina, el sistema operativo (kernel) deja información como el PID del proceso y su estado de terminación en la tabla de procesos. Luego envía una señal SIGCHLD al proceso padre (indicando que el hijo ha terminado).

  5. El proceso padre, al recibir esta señal, debe llamar a la llamada al sistema wait() para "cosechar" la información del estado de terminación del hijo. Una vez cosechada dicha información, el kernel podrá eliminar completamente la entrada del hijo de la tabla de procesos.

Un proceso zombie es aquel que queda atrapado entre los pasos 4 y 5. Es decir, el proceso hijo ha completado su ejecución y ha terminado, pero el proceso padre aún no ha llamado a wait() para cosechar la información de estado de terminación.

Como su nombre indica, este proceso está en un estado de muerte (no en ejecución). Por lo tanto, no consume recursos del sistema, como CPU o memoria.

¿Por qué son un problema los procesos zombie?

Los procesos zombie en sí no utilizan muchos recursos del sistema, pero ocupan una ranura (PID) en la tabla de procesos.

Si debido a un error en el proceso padre, los procesos zombie continúan acumulándose sin ser eliminados, se puede alcanzar el número máximo de PIDs que el sistema puede asignar. En este caso, el sistema dejará de ser capaz de crear nuevos procesos, lo que podría llevar a fallos severos. No es raro que se vean 1 o 2 zombies en top, pero si este número sigue aumentando, se requiere acción.

Cómo verificar e identificar procesos zombie

El comando top solo muestra la _cantidad_ de zombies. Para saber qué proceso está en estado zombie y quién es su padre, se debe utilizar el comando ps.

La forma más sencilla es buscar procesos indicados como 'Z' en la columna STAT del comando ps.

# Ver todos los procesos del sistema y filtrar por estado 'Z' (zombie)
ps -elf | grep ' Z '

# O usar la opción 'aux' (la 8ª columna($8) es el estado (STAT))
ps aux | awk '$8=="Z"'

Salida de ejemplo:

# ps -elf | grep ' Z '
F S   UID   PID  PPID  C PRI  NI ADDR SZ WCHAN  STIME TTY          TIME CMD
0 Z  user  5021  5000  0  80   0 -     0 exit   15:30 ?        00:00:00 [defunct]

Los datos importantes en el ejemplo anterior son:

  • S (Estado): Z (indica que está en estado zombie)

  • PID: 5021 (este es el PID del proceso zombie)

  • PPID: 5000 (este es el PID del proceso padre que no ha cosechado el zombie)

  • CMD: [defunct] (indica que ha terminado pero no ha sido limpiado)

Cómo resolver procesos zombie

El hecho más importante es que los procesos zombie no pueden ser eliminados con el comando kill.

kill -9 5021 (el PID zombie del ejemplo anterior)

Este comando no funcionará porque el zombie ya está en un estado "muerto". No hay nadie que pueda manejar la señal kill.

La única forma de resolver el problema de un proceso zombie es hacer que el proceso padre llame a wait().

Paso 1: Enviar señal al proceso padre (recomendado)

La primera opción a intentar es enviar manualmente la señal SIGCHLD al proceso padre (PPID) para que verifique el estado de su hijo.

# Enviar señal SIGCHLD al PID padre del ejemplo (5000)
kill -s SIGCHLD 5000

Esto permite que el proceso padre reciba la notificación de "¡uno de tus procesos hijos ha terminado, verifícalo!" Si el padre está programado correctamente, recibirá esta señal y cosechará el zombie.

Paso 2: Forzar la terminación del proceso padre (último recurso)

Si el paso 1 no funciona, significa que el proceso padre (PPID 5000) está detenido o tiene un error serio en la lógica que llama a wait().

En este caso, la única solución es forzar la terminación del proceso padre.

# Terminar el proceso padre (PPID 5000)
kill 5000

# Si aún no se detiene, forzar la terminación
kill -9 5000

¿Por qué al matar al padre se resuelve el problema?

En Linux, cuando un proceso padre muere, sus procesos hijos (procesos huérfanos) son automáticamente adoptados por el proceso init (PID 1) o systemd. El proceso init está diseñado para verificar periódicamente el estado de sus hijos y cosechar inmediatamente a los hijos que han terminado (incluyendo los zombies).

Por lo tanto, si el problemático padre (PPID 5000) muere, el zombie (PID 5021) se convierte en el nuevo hijo de init, y init lo limpia de inmediato.

⚠️ Advertencia: Antes de finalizar un proceso padre, asegúrate de verificar con el comando ps -p 5000 (PID del padre) que no sea un servicio crítico para el sistema (por ejemplo, DB, servidor web, etc.). Terminar forzosamente un servicio crítico puede causar fallos más graves.

Resumen

  • Un proceso zombie es un remanente en la tabla de procesos de un proceso que ha terminado, pero cuyo padre no ha cosechado su estado de terminación.

  • No consume recursos, pero ocupa un PID y, si hay demasiados, puede causar caídas del sistema.

  • Se pueden localizar zombies (PID) y su padre (PPID) usando el comando ps -elf | grep ' Z '.

  • La solución se enfoca en el proceso padre (PPID) en lugar del zombie.

    1. kill -s SIGCHLD <parentPID> (recomendado)

    2. kill <parentPID> (último recurso)