Cómo matar un proceso en Linux (y por qué vuelve)
Encuentra el proceso colgado con ps y pgrep, termínalo con SIGTERM y usa SIGKILL solo al final. Y qué hacer si systemd o Docker lo reinician, si ocupa un puerto o es un zombi.
Respuesta corta: cómo matar un proceso en Linux
Para matar un proceso en Linux, primero busca su PID (identificador de proceso) con ps o pgrep. Después ejecuta kill PID, que pide al programa que termine. Si sigue vivo tras unos segundos, usa kill -9 PID, que envía SIGKILL; si está en sueño no interrumpible, puede seguir vivo hasta que termine su espera dentro del kernel.
Eso resuelve el caso fácil. En un servidor hay casos más difíciles. El proceso vuelve a aparecer porque systemd o Docker lo reinicia. No sabes qué programa ocupa un puerto. ps muestra un proceso que ningún kill borra. O pkill termina más procesos de los que querías. Esta guía cubre esos cuatro casos. Todos los ejemplos usan procesos que tú mismo arrancas, como sleep o un servidor web de prueba, así puedes practicar sin tocar nada importante.
Encuentra el proceso colgado o el que consume CPU
Cuando el servidor va lento, empieza por una lista ordenada por uso de CPU:
ps -eo pid,user,%cpu,%mem,cmd --sort=-%cpu | head -n 15-e selecciona todos los procesos. -o elige las columnas: PID, usuario, CPU, memoria y la línea de comandos completa (cmd). El signo menos en --sort=-%cpu invierte el orden, así que el proceso que más CPU usa sale primero.
Un detalle importante: el %cpu de ps no es el uso de este momento. Es el tiempo de CPU dividido por el tiempo que el proceso lleva vivo. Un proceso que pasó días tranquilo y empezó a consumir hace un minuto puede salir abajo en la lista. Si la lista no explica la carga, mira la columna de CPU en top durante unos segundos. Y si el culpable tiene un nombre que no reconoces, como kswapd0, lee primero si kswapd0 con CPU alta es falta de memoria o un minero antes de matar nada.
Cuando ya sabes el nombre, pgrep y pidof te dan el PID directamente:
pgrep -a sleep
pidof sleeppgrep compara el patrón con el nombre del proceso. Con -a muestra también la línea de comandos completa, y eso es lo que necesitas para no confundir dos procesos con el mismo nombre. pidof imprime solo los PID del programa que nombras. Con -s devuelve uno solo. Los dos terminan con estado de salida 1 si no encuentran nada, lo cual sirve en scripts.
Pide que termine: kill y SIGTERM
Una señal es un aviso corto que el kernel entrega a un proceso. kill sin opciones envía SIGTERM, la señal 15, que significa «termina, por favor». El programa puede atraparla, cerrar sus archivos, borrar su archivo de PID y salir limpio. Por eso SIGTERM siempre va primero.
Abre dos terminales. En la primera, arranca un proceso de prueba:
sleep 300En la segunda, termínalo:
kill $(pgrep -x sleep)-x exige que el nombre sea exactamente sleep. Así no tocas otro programa cuyo nombre solo contenga esa palabra. Si tienes otros sleep en marcha, pasa el PID concreto en lugar de $(pgrep -x sleep). Vuelve a la primera terminal y mira el estado de salida:
echo $?
kill -l 143Bash documenta que un comando terminado por la señal n devuelve 128 + n. SIGTERM es la 15, así que deberías ver 143. kill -l seguido de un estado de salida imprime el nombre de la señal correspondiente, y kill -l solo lista todos los nombres. Es una forma rápida de saber qué señal terminó un proceso cuando ves un 143 o un 137 en un log.
Fuerza el final con kill -9 (SIGKILL)
Si el programa ignora SIGTERM o está colgado, dale unos segundos de gracia y después usa SIGKILL, la señal 9. Este bucle hace las dos cosas con un PID concreto:
PID=12345
kill "$PID"
for i in $(seq 10); do
kill -0 "$PID" 2>/dev/null || break
sleep 1
done
kill -0 "$PID" 2>/dev/null && kill -9 "$PID"kill -0 no envía ninguna señal. Solo comprueba si el proceso existe y si tienes permiso sobre él. El bucle espera hasta 10 segundos, y solo si el proceso sigue vivo envía kill -9. Repite la prueba de sleep 300 usando kill -9: echo $? debería mostrar 137, es decir 128 + 9.
SIGKILL no se puede atrapar, bloquear ni ignorar. El kernel termina el proceso sin ejecutar sus manejadores de limpieza, pero una espera no interrumpible dentro del kernel puede retrasar su terminación. Eso es lo que lo hace eficaz, y también lo que lo hace peligroso. Como el programa nunca recibe un aviso, no llega a hacer nada de esto:
- ejecutar sus manejadores de limpieza, el código que corre al recibir SIGTERM;
- escribir en disco los datos que todavía tenía en memoria;
- borrar sus archivos de bloqueo, que pueden impedir el siguiente arranque;
- borrar su archivo de PID, que puede hacer creer a un script que el programa sigue vivo.
Por eso kill -9 es el segundo paso, nunca el primero.
Un aviso más. Un PID menor que -1 envía la señal a un grupo de procesos entero, y kill -9 -1 la envía a todos los procesos que puedes señalar excepto PID 1 y el propio proceso que hace la llamada. Como root, eso termina casi todo el servidor, incluida tu sesión SSH. Revisa el número antes de pulsar Enter.
Practica con un script que ignora SIGTERM
Este script simula un programa que no atiende la petición de terminar:
cat > ~/terco.sh <<'EOF'
#!/bin/bash
trap '' TERM
while true; do sleep 1; done
EOF
chmod +x ~/terco.sh
~/terco.sh &
pgrep -af terco.shtrap '' TERM define una acción vacía para SIGTERM. Bash documenta que, con una acción vacía, la señal queda ignorada por la shell y por los comandos que lanza. Ahora intenta terminarlo:
pkill -f terco.sh
pgrep -af terco.shEl script sigue en la lista, porque la señal llegó y el script la ignoró. Usa ahora la señal que no se puede ignorar:
pkill -9 -f terco.sh
pgrep -af terco.shEsta vez pgrep no devuelve nada. Es el mismo caso que un programa real que no responde a SIGTERM: SIGKILL fuerza su terminación, aunque una espera no interrumpible puede retrasarla, con todo lo que se pierde.
¿Por qué el proceso vuelve después de matarlo?
Matas el proceso y, unos segundos después, pgrep lo vuelve a mostrar con otro PID. No es el mismo proceso. Es uno nuevo que arrancó un supervisor. En un VPS casi siempre es systemd o Docker, así que tienes que detener el servicio o el contenedor, no el proceso.
Cuando lo reinicia systemd
Pregunta a systemd a qué unidad pertenece el PID:
systemctl status 12345systemctl status acepta un PID y muestra la unidad que lo contiene. Si esa unidad tiene Restart=always, systemd la vuelve a arrancar tanto si el proceso salió limpio como si lo terminó una señal, salvo las excepciones de RestartPreventExitStatus= y los límites de frecuencia de arranque. Tu kill es justo eso: una señal desde fuera. En cambio, un systemctl stop no provoca reinicio. Detén la unidad:
sudo systemctl stop nombre.service
sudo systemctl disable nombre.servicedisable elimina los enlaces de habilitación para el arranque, pero otras unidades todavía pueden activarla. Si otra cosa la vuelve a arrancar, sudo systemctl mask nombre.service enlaza el archivo de la unidad a /dev/null, y así es imposible arrancarla. sudo systemctl unmask nombre.service lo deshace.
systemctl stop ejecuta primero los comandos de ExecStop= si están definidos y después termina los procesos restantes según la configuración de la unidad. Con los valores por defecto, envía SIGTERM (KillSignal=) a todos los procesos del grupo de control de la unidad (KillMode=control-group), espera hasta TimeoutStopSec= y después envía SIGKILL a los que queden. La documentación de systemd fija esa espera por defecto en 90 segundos (DefaultTimeoutStopSec=). Tu distribución o la propia unidad pueden cambiarla, así que compruébalo con systemctl show nombre.service -p TimeoutStopUSec.
Para enviar una señal concreta sin detener la unidad, usa sudo systemctl kill --signal=SIGHUP nombre.service. Si quieres entender cuándo systemd reinicia un servicio y cuándo no, lee cómo funcionan las políticas de reinicio de systemd. Y si matas el mismo servicio cada hora porque consume demasiado, suele ser mejor limitar la memoria y la CPU de un proceso con systemd.
Cuando lo reinicia Docker
Los procesos de un contenedor aparecen en el ps del servidor. Si matas el proceso principal y el contenedor tiene una política de reinicio como always, Docker arranca el contenedor otra vez. Trabaja con el contenedor:
sudo docker ps
sudo docker stop nombre_contenedor
sudo docker update --restart=no nombre_contenedordocker stop envía al proceso principal del contenedor la señal de parada configurada, SIGTERM por defecto, y SIGKILL si no termina después del período de gracia. Ese período es de 10 segundos por defecto en Linux, y -t lo cambia. Ojo con un detalle: con la política always, un contenedor detenido a mano vuelve a arrancar cuando se reinicia el demonio de Docker, por ejemplo al reiniciar el servidor. docker update --restart=no quita la política para que eso no ocurra.
Qué proceso ocupa un puerto y cómo terminarlo
El error típico es Address already in use al arrancar un servicio. Para practicar, arranca un servidor web de prueba en el puerto 8080:
command -v python3 || sudo apt install -y python3
python3 -m http.server 8080 --bind 127.0.0.1 &
sudo ss -ltnp 'sport = :8080'En ss, -l muestra solo los sockets en escucha, -t limita a TCP, -n muestra números en lugar de nombres de servicio y -p añade el proceso que usa cada socket. La última columna nombra el programa y su PID. Ejecútalo con sudo para que ss pueda mostrar también procesos de otros usuarios.
lsof ofrece otra forma de llegar al PID, y con -t imprime solo los números, sin cabecera, listos para kill:
command -v lsof || sudo apt install -y lsof
sudo lsof -i TCP:8080 -sTCP:LISTEN
sudo kill $(sudo lsof -t -i TCP:8080 -sTCP:LISTEN)Mira siempre la primera salida antes de usar -t. -i TCP:8080 selecciona todo socket cuya dirección use ese puerto, así que también lista los clientes conectados al 8080, no solo al programa que escucha.
fuser hace lo mismo en un solo paso, pero con una trampa:
command -v fuser || sudo apt install -y psmisc
sudo fuser -v 8080/tcp
sudo fuser -k -TERM 8080/tcpfuser -k envía SIGKILL por defecto, sin pasar por SIGTERM. Añade -TERM para respetar el orden de esta guía. Después, comprueba que el puerto quedó libre con cómo comprobar si un puerto está abierto en Linux. Si el puerto vuelve a estar ocupado a los pocos segundos, comprueba si el que lo ocupa es un servicio con reinicio automático: vuelve a la sección anterior.
Por qué no puedes matar un proceso zombi
Un zombi aparece con la letra Z en la columna de estado. Búscalos junto con su padre:
ps -eo pid,ppid,stat,cmd | awk '$3 ~ /^Z/'ps define el estado Z como un proceso «terminado pero no recogido por su padre». El zombi ya está muerto. Lo único que queda es una entrada en la tabla de procesos del kernel, que guarda su estado de salida hasta que el padre lo lea con wait. Por eso kill no tiene nada que terminar.
La solución está en el padre, cuyo PID ves en la columna ppid. Si el padre es un servicio, reinícialo con systemctl restart. Si no, termínalo con kill. Cuando un padre muere, sus zombis pasan al ancestro más cercano configurado como subreaper, que debe recogerlos con wait, o a init (PID 1), que los recoge automáticamente. Unos pocos zombis no hacen daño. Muchos zombis que no paran de crecer indican un fallo en el programa padre, y si llenan la tabla de procesos, el sistema ya no puede crear procesos nuevos.
Procesos en estado D: cuando kill -9 no hace nada visible
ps define el estado D como «sueño no interrumpible (normalmente E/S)». E/S significa entrada y salida: el proceso espera dentro del kernel a que termine una operación de disco o de red, por ejemplo en un montaje NFS que ya no responde. Búscalos así:
ps -eo pid,stat,cmd | awk '$2 ~ /^D/'Si después de kill -9 el proceso sigue en D, la señal no es el problema. El problema es aquello que el proceso espera, el disco o el montaje remoto. Lee los últimos mensajes del kernel con sudo dmesg | tail -n 50 y busca errores del dispositivo. El proceso sale de esa espera cuando se cumple la condición que espera dentro del kernel; desmontar el recurso no garantiza que eso ocurra.
Cuidado: pkill -f mata más de lo que querías
Sin opciones, pkill compara el patrón solo con el nombre del proceso. Con -f lo compara con la línea de comandos completa. Eso es útil para scripts, que se llaman bash o python3, pero el alcance crece mucho. pkill -f python termina tu servidor de prueba, y también cualquier proceso cuya línea de comandos contenga esa palabra, como nano notas-python.txt.
pkill nunca se elige a sí mismo. Pero otro proceso que lo lanza sí puede coincidir. Si ejecutas bash -c 'pkill -f terco.sh', o la misma línea desde cron o por SSH, la shell que la envuelve tiene terco.sh en su propia línea de comandos, así que el patrón también la describe a ella. Dos hábitos evitan sorpresas:
pgrep -af 'terco.sh'
pkill -f '[t]erco.sh'El primero muestra, antes de enviar nada, exactamente qué procesos coinciden. El segundo usa una expresión regular: [t] coincide con la letra t, así que el patrón encuentra terco.sh. Sin embargo, el texto literal [t]erco.sh que aparece en la línea de la shell no coincide consigo mismo. pkill devuelve 0 si encontró y señaló al menos un proceso, y 1 si no encontró ninguno o no pudo señalar a ninguno de los que coincidían.
killall: terminar por nombre exacto
killall nombre envía SIGTERM a todos los procesos que ejecutan ese comando, y con -w espera a que mueran. Viene en el paquete psmisc. Si no lo tienes, instálalo:
command -v killall || sudo apt install -y psmisc
killall -w sleepEn otros sistemas Unix, killall puede hacer algo muy distinto, así que no copies esta línea en un servidor que no sea Linux.
Por último, la situación contraria. Si tu proceso muere solo cuando cierras la sesión SSH, una causa es SIGHUP, la señal 1, que llega al cerrarse el terminal y que Bash también reenvía a sus trabajos cuando la recibe. Para evitarlo, mira cómo mantener un comando en marcha después de desconectar SSH.
FAQ
¿Qué diferencia hay entre kill y kill -9 en Linux?
kill sin opciones envía SIGTERM, la señal 15, que pide al programa que termine. El programa puede atraparla, guardar sus datos y borrar sus archivos de bloqueo antes de salir. kill -9 envía SIGKILL, que no se puede atrapar ni ignorar y termina el proceso sin limpiar nada, aunque una espera no interrumpible dentro del kernel puede retrasar su terminación. Usa siempre kill primero, espera unos segundos y usa kill -9 solo si el proceso sigue vivo.
¿Por qué el proceso vuelve a aparecer después de matarlo?
Casi siempre lo reinicia un supervisor. Ejecuta systemctl status PID para ver si pertenece a una unidad de systemd. Si es así, usa sudo systemctl stop y sudo systemctl disable con esa unidad, porque Restart=always reinicia el servicio tras su terminación salvo las excepciones de RestartPreventExitStatus= y los límites de frecuencia de arranque, pero no después de systemctl stop. Si el proceso vive en un contenedor, usa docker stop y docker update --restart=no.
¿Cómo sé qué proceso usa un puerto y cómo lo termino?
Ejecuta sudo ss -ltnp 'sport = :8080' (cambia el número por tu puerto). La última columna muestra el programa y su PID. También puedes usar sudo lsof -i TCP:8080 -sTCP:LISTEN para verlo y sudo kill $(sudo lsof -t -i TCP:8080 -sTCP:LISTEN) para terminarlo. Si usas fuser -k, añade -TERM, porque por defecto envía SIGKILL directamente.
¿Cómo elimino un proceso zombi que no muere con kill -9?
Un zombi ya está muerto, así que ninguna señal puede terminarlo. Es solo una entrada en la tabla de procesos que espera a que su padre la recoja. Busca el PID del padre con ps -eo pid,ppid,stat,cmd y reinicia o termina ese padre. Entonces lo adopta el ancestro más cercano configurado como subreaper, que debe recogerlo con wait, o init (PID 1), que lo recoge automáticamente.