Procesos en Linux: PID, estados y señales
Los procesos son la unidad activa de trabajo en Linux. Entenderlos te permite diagnosticar rendimiento, cerrar programas mal portados y diseñar scripts que controlen el sistema sin romperlo. Vamos paso a paso —sin jerga aburrida— para que cuando veas un PID no te agarre pánico.
¿Qué es un proceso?
Un proceso es una instancia en ejecución de un programa. Contiene la información necesaria para que el kernel administre su ejecución: la imagen en memoria (código y datos), pila, registros de CPU, descriptores de archivos abiertos, variables de entorno y metadatos como el PID (Process ID).
Piensa en un proceso como una ficha con todo lo que hace falta para que el kernel pueda «correr» un programa y pausarlo, reanudarlo o terminarlo cuando haga falta.
PID: la identidad del proceso
El PID (identificador de proceso) es un número único para cada proceso en ejecución dentro de un sistema en un momento dado. Algunos valores y conceptos clave:
- PID 1: es el primer proceso que arranca en el espacio de usuario (init/systemd). Supervisa el arranque y reaparece procesos huérfanos.
- PPID: Parent PID, el proceso que creó al actual (fork/exec).
- Los PID se reciclan: cuando un proceso termina, su número puede asignarse a otro proceso nuevo.
Ver procesos y sus PID:
$ ps aux | head
USER PID %CPU %MEM VSZ RSS TTY STAT START TIME COMMAND
root 1 0.0 0.1 169084 9288 ? Ss 09:00 0:05 /sbin/init
mauro 2345 0.3 1.2 245000 25512 pts/0 S+ 09:12 0:00 /usr/bin/bashEstados de procesos: ¿qué significa cada letra?
Un proceso puede encontrarse en distintos estados. Las interfaces como ps o el kernel suelen representar estados con letras (y palabras en documentación). Aquí los más importantes:
- R (Running): ejecutándose o listo para ejecutarse.
- S (Sleeping): esperando un evento (I/O, timer). La mayoría de procesos suelen estar aquí la mayor parte del tiempo.
- D (Uninterruptible sleep): sueño no interrumpible (ej.: esperando I/O de disco). Cuidado con procesos que se quedan en D mucho tiempo.
- T (Stopped): detenido, por ejemplo por
SIGSTOPo por depuración. - Z (Zombie): proceso terminado pero cuyo padre no leyó su código de salida —existe solo como entrada en la tabla de procesos hasta que el padre hace
wait().
Ojo: los zombies no consumen CPU ni memoria significativa (solo una entrada en la tabla de procesos), pero muchos zombies pueden indicar un problema de supervisión de procesos.
Cómo se crean y destruyen procesos: fork y exec
En Linux (y Unix) la creación de procesos normalmente pasa por dos pasos clásicos:
fork(): el proceso padre crea una copia casi idéntica de sí mismo; ahora existen dos procesos con distinto PID.exec(): el proceso (normalmente el hijo) reemplaza su imagen en memoria por un nuevo programa (por ejemplo, pasar de un intérprete a un binario).
Esto explica por qué muchos procesos están relacionados jerárquicamente y por qué al matar un proceso hijo el padre puede reaccionar (por ejemplo, reiniciarlo).
Señales: comunicando al proceso
Las señales son la forma tradicional y ligera de comunicarse con procesos. El kernel y los usuarios pueden enviar señales para pedir acciones (terminar, pausar, recargar configuración, etc.). Algunas señales importantes:
- SIGTERM (15): petición educada de terminación. El proceso puede capturarla y limpiar recursos.
- SIGKILL (9): termina el proceso de forma inmediata y no puede ser capturada ni ignorada. Uso de último recurso.
- SIGHUP (1): históricamente “hangup” —muchas aplicaciones lo usan para recargar configuración sin cerrar.
- SIGSTOP / SIGCONT: suspender y reanudar un proceso (SIGSTOP no puede ser ignorada).
- SIGCHLD: enviada al padre cuando un hijo cambia de estado (termina, es detenido, etc.).
Enviar señales desde la terminal:
# Pedir terminación educada
$ kill 2345
# Forzar terminación
$ kill -9 2345
# Enviar SIGHUP
$ kill -SIGHUP 2345Precaución: usar kill -9 impide que el proceso limpie archivos temporales o desconecte servicios de forma ordenada. Antes de usarlo, probá kill sin -9 y revisá logs.
Herramientas útiles para observar procesos
Algunas utilidades indispensables para diagnosticar procesos:
ps: lista procesos (snapshot). Muy útil conps auxops -ef.top/htop: monitorización en tiempo real (consumo CPU/RAM, estados, PIDs).pstree: muestra la jerarquía padre-hijo en forma de árbol.strace: rastrea llamadas al sistema de un proceso (muy útil para debugging).lsof: qué archivos (y sockets) tiene abiertos un proceso.
# Ver procesos ordenados por memoria (top)
$ top
# Ver árbol de procesos
$ pstree -p
# Qué archivos tiene abierto el proceso PID
$ sudo lsof -p 2345Zombies y huérfanos: qué son y cómo actuar
Zombie: proceso terminado cuyo padre aún no llamó a wait(). Aparece en ps con estado Z. Normalmente el padre debería recogerlo; si no, el zombie persiste hasta que el padre termine o se reubique.
Huérfano: proceso cuyo padre terminó antes que él. El kernel re-asigna estos procesos a PID 1 (systemd/init), que suele adoptarlos y limpiarlos correctamente.
Soluciones prácticas:
- Si ves uno o dos zombies, normalmente no es crítico. Muchos zombies indican bug en la aplicación (no maneja hijos correctamente).
- Si el padre está vivo y no gestiona los hijos, podés reiniciar el servicio o, en último caso, matar el padre (y systemd adoptará/hara reapertura según el caso).
Ejemplo práctico: reiniciar un servicio sin matar a mano procesos
Supongamos que un servicio tiene procesos colgados. En sistemas con systemd, lo correcto es usar el propio gestor de servicios:
# Reiniciar de forma ordenada con systemd
$ sudo systemctl restart nombre-del-servicio
# Ver procesos del servicio
$ systemctl status nombre-del-servicio
$ ps -ef | grep nombre-del-servicioEvitar el uso masivo de kill -9; preferí siempre herramientas de supervisión (systemd, supervisord) que saben cómo reiniciar y recoger hijos.
Buenas prácticas y consejos rápidos
- No matar procesos a ojo: identificá qué hace el proceso (
lsof,strace, logs) antes de decidir. - Usá systemd para servicios:
systemctlmaneja dependencias, reinicios y logs conjournalctl. - Monitoreo: herramientas como
htop, Prometheus o Grafana te ayudan a detectar procesos que consumen recursos anómalos. - Scripts seguros: si un script arranca procesos en background, asegurate de controlar PID y usar
trappara limpiar en exit.
Lecturas recomendadas
Conclusión
Entender procesos en Linux te pone en control del sistema. Saber qué es un PID, reconocer estados (sleeping, running, zombie) y usar señales de forma responsable te salva de falsas alarmas y reinicios innecesarios. La próxima vez que veas un proceso que «consume mucho», tendrás herramientas para investigarlo y actuar con criterio.
