Cómo matar procesos en Linux con kill y killall: guía completa

Si usas Linux, seguro te ha pasado: la computadora se pone lenta, Eclipse se congela, Android Studio deja de responder o Chrome empieza a comportarse de manera extraña. En la mayoría de los casos, esto ocurre porque un proceso consume demasiados recursos o se queda atascado en un estado del que no puede salir por sí solo. La solución más rápida y efectiva es terminar ese proceso directamente desde la terminal para liberar memoria y CPU, sin necesidad de reiniciar el sistema.

Dependiendo de la distribución de Linux que uses, su versión, los programas instalados y los recursos disponibles, muchas cosas pueden salir mal y provocar que la computadora —o un programa en particular— se "cuelgue". Esto sucede con bastante frecuencia en aplicaciones que consumen muchos recursos, como Android Studio, emuladores, IAs locales, XCode o videojuegos.

En estos casos, lo correcto es "matar" o terminar el proceso (o los procesos) asociados al programa para liberar los recursos del sistema y, si es necesario, reiniciar la aplicación desde cero.

Cómo matar procesos en Linux: conceptos básicos

En Linux, un proceso es la ejecución de un programa en memoria. El sistema operativo asigna recursos a cada proceso (CPU, RAM, descriptores de archivo) y los gestiona de forma independiente. Para controlarlos y terminarlos cuando es necesario, existen herramientas de línea de comandos como kill y killall. Ambas permiten finalizar procesos, pero funcionan de forma distinta y se aplican en situaciones diferentes.

Los comandos kill y killall para terminar procesos

Existe un par de comandos que permiten realizar esta tarea de manera sencilla y directa desde la terminal: kill y killall. Ambos envían señales al proceso para indicarle que debe detenerse, aunque difieren en cómo identifican al proceso objetivo.

Qué es un PID y por qué es importante

Cada proceso en Linux tiene un PID (Process ID), un número único que lo identifica mientras está en ejecución. El comando kill necesita este PID para saber exactamente qué proceso terminar. Esto lo convierte en la opción ideal cuando quieres tener precisión absoluta: por ejemplo, cerrar una instancia concreta de Chrome que se colgó, sin afectar otras ventanas o pestañas que siguen funcionando bien.

Cómo obtener el PID con ps y grep

Para localizar el PID de un proceso, puedes usar la combinación de ps aux con grep:

ps aux | grep nombre_del_proceso

Por ejemplo, si quieres encontrar el PID de Gedit:

ps aux | grep gedit

Esto devuelve algo como:

andres   10081  0.3  0.7 666388 35004 ?        Sl   11:21   0:00 /usr/bin/gedit

El PID aquí es 10081. La segunda columna de la salida de ps aux siempre es el identificador del proceso.

Ejemplo práctico del comando kill

Para emplear el comando kill necesitas conocer el identificador del proceso que quieres terminar. Para eso, primero ejecuta ps aux para listar todos los procesos activos del sistema:

...
3036 ?        S      0:00 /opt/google/chrome/chrome --type=zygote --enable-crash-reporter=DFD73122-B4B8-416D-A254-9ABF21A8B36E
 3056 ?        Sl     4:35 /proc/self/exe --type=gpu-process --channel=3019.0.65190361 --enable-crash-reporter=DFD73122-B4B8-416D-A254-9ABF2
 3062 ?        S      0:00 /proc/self/exe --type=gpu-process --channel=3019.0.65190361 --enable-crash-reporter=DFD73122-B4B8-416D-A254-9ABF2
 3145 ?        Sl     0:08 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=AffiliationBasedMatching/Enabled/Audi
 3149 ?        Sl     0:00 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=AffiliationBasedMatching/Enabled/Audi
 3152 ?        Sl     0:00 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=AffiliationBasedMatching/Enabled/Audi
 3225 ?        Sl     0:00 /usr/libexec/gvfsd-trash --spawner :1.5 /org/gtk/gvfs/exec_spaw/0
 3268 ?        Sl     1:01 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=AffiliationBasedMatching/Enabled/Audi
 3525 ?        S      0:00 /home/andres/sts-bundle/sts-3.6.4.RELEASE/STS
 3527 ?        Sl     5:07 /usr/bin/java -Dosgi.requiredJavaVersion=1.6 -Xms40m -Xmx768m -XX:MaxPermSize=256m -jar /home/andres/sts-bundle/s
 4306 ?        Sl     6:14 /usr/lib/jvm/java-1.8.0-openjdk-1.8.0.60-14.b27.fc21.x86_64/bin/java -Dcatalina.base=/home/andres/sts-bundle/pivo
 4349 ?        Ss     0:02 postgres: postgres oo 127.0.0.1(50352) idle
 4468 ?        Sl     0:17 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=*AffiliationBasedMatching/Enabled/Aud
 5568 ?        Sl     0:16 /opt/google/chrome/chrome --type=renderer --lang=es-419 --force-fieldtrials=*AffiliationBasedMatching/Enabled/Aud
 6278 ?        Sl     0:02 /usr/bin/nautilus --gapplication-service
 7712 ?        Sl     0:03 /usr/bin/pgadmin3
 8381 ?        S      0:00 [kworker/u4:2]
 9967 ?        Rl     0:00 /usr/libexec/gnome-terminal-server
 9971 pts/0    Ss     0:00 bash
10081 ?        Sl     0:00 /usr/bin/gedit --gapplication-service
10088 ?        S      0:00 [kworker/u4:1]
...

Filtrando procesos con ps y grep

Como puedes ver, el sistema maneja decenas de procesos en paralelo, la mayoría internos del propio sistema operativo y que no fueron iniciados directamente por ti. Para encontrar rápidamente el proceso que te interesa, combina ps con grep:

ps aux | grep gedit

Esto devuelve un listado mucho más reducido y legible:

andres   10081  0.3  0.7 666388 35004 ?        Sl   11:21   0:00 /usr/bin/gedit --gapplication-service
andres   10231  0.0  0.0 113020  2248 pts/0    S+   11:24   0:00 grep --color=auto gedit

Ahora podemos terminar el programa Gedit asociado al PID 10081 con el siguiente comando:

kill 10081

Si el proceso ya no existe, Linux te lo indicará con un mensaje como este:

kill 41076
bash: kill: (41076) - No existe el proceso

La sintaxis básica del comando es:

kill PID

Por defecto, kill envía la señal SIGTERM (15), que le pide al proceso que se cierre de forma ordenada —guardando archivos, cerrando conexiones, liberando recursos—. Si el proceso no responde a esa señal, puedes forzar su terminación inmediata con SIGKILL (9):

kill -9 PID

Señales más comunes de kill y cuándo utilizarlas:

• SIGTERM (15): termina el proceso de forma ordenada. Es la señal por defecto y la que debes usar siempre como primer intento.
• SIGKILL (9): fuerza la terminación inmediata. El proceso no puede ignorarla ni limpiar recursos. Úsala solo si SIGTERM no funcionó.
• SIGHUP (1): recarga la configuración del proceso sin detenerlo. Muy útil en servidores y demonios como nginx o sshd.
• SIGINT (2): interrumpe procesos en primer plano, equivalente a presionar Ctrl + C en la terminal.
• Regla general: empieza siempre con SIGTERM y recurre a SIGKILL solo si el proceso no responde tras varios segundos.

El comando killall: matar procesos por nombre

Con killall la cosa se simplifica bastante: no necesitas buscar el PID, basta con conocer el nombre del proceso que quieres terminar. Es la opción más rápida cuando sabes exactamente qué programa quieres cerrar y no te importa cerrar todas sus instancias a la vez.

Diferencias clave entre kill y killall:

• kill: necesita el PID → control preciso sobre un proceso específico.
• killall: usa el nombre del proceso → cierra todas las instancias activas con ese nombre.

Por ejemplo, para terminar todas las instancias de Firefox:

killall firefox

Para cerrar Gedit:

killall gedit

Para cerrar pgAdmin3:

killall pgadmin3

Para cerrar Google Chrome:

killall google-chrome

Para cerrar Nautilus (el explorador de archivos de GNOME):

killall nautilus

Si el proceso que intentas terminar no está en ejecución, killall te lo avisará:

killall pgadmin3
pgadmin3: no process found

Como ves, la única condición para usar killall es conocer el nombre exacto del proceso tal y como aparece en el sistema. Y aquí viene el detalle más importante: killall es sensible a mayúsculas y minúsculas, así que Firefox y firefox son procesos diferentes para este comando.

kill vs killall: cuál usar en cada situación

• Usa kill cuando quieras cerrar un proceso específico y ya conoces su PID. Es la opción más segura y controlada.
• Usa killall cuando quieras cerrar todas las instancias de un programa de golpe y conoces su nombre exacto.
• En servidores o sistemas críticos, verifica siempre qué procesos vas a terminar antes de ejecutar cualquiera de los dos comandos. Matar un proceso equivocado con privilegios de root puede desestabilizar el sistema.

Errores comunes al usar kill y killall

• killall es sensible a mayúsculas/minúsculas: firefox no es igual que Firefox. Si el nombre no coincide exactamente, el comando no encontrará el proceso.
• Cerrar instancias no deseadas: killall termina todas las instancias con ese nombre. Si tienes varias ventanas de Firefox abiertas, las cerrará todas sin distinción.
• Usar -9 sin necesidad: kill -9 o killall -9 fuerzan el cierre inmediato sin dar tiempo al proceso a guardar su estado. Esto puede provocar pérdida de datos o archivos corruptos. Úsalo solo como último recurso.
• Matar procesos del sistema como root sin precaución: terminar procesos esenciales del sistema operativo puede provocar un colapso completo de Linux o dejarlo en un estado inestable.
• No verificar procesos hijos: cuando terminas un proceso padre, Linux también cierra sus procesos hijos. Esto puede causar pérdidas de trabajo inesperadas si no identificas bien la jerarquía de procesos primero.

Consejos prácticos para terminar procesos sin romper el sistema

• Identifica siempre el PID o el nombre exacto del proceso antes de ejecutar cualquier comando.
• Evita kill -9 a menos que el proceso lleve tiempo sin responder a SIGTERM.
• Para identificar qué procesos consumen más recursos, usa top o su versión mejorada htop (más visual e interactiva). Ambas muestran en tiempo real el consumo de CPU y memoria de cada proceso.
• Combina ps aux | grep nombre para filtrar procesos concretos y confirmar su PID antes de ejecutar kill.
• Si necesitas obtener solo el PID de forma rápida sin parsear la salida de ps, puedes usar pgrep nombre_proceso o pidof nombre_proceso. Ambos devuelven únicamente los PIDs coincidentes.

Preguntas frecuentes sobre kill y killall en Linux

• ¿Cuál es la diferencia entre kill y killall?
  • kill actúa sobre un proceso usando su PID, lo que te da control preciso. killall actúa por nombre y cierra todas las instancias de ese proceso a la vez.
• ¿Qué pasa si uso kill -9?
  • Fuerza el cierre inmediato del proceso sin que este pueda limpiar su estado ni guardar datos. Puede provocar pérdida de archivos o datos no guardados. Úsalo solo si el proceso no responde a SIGTERM.
• ¿Cómo saber el PID de un proceso en Linux?
  • Puedes usar ps aux | grep nombre_proceso, pidof nombre_proceso o pgrep nombre_proceso. Los tres devuelven el PID del proceso buscado.
• ¿Es peligroso usar killall?
  • Puede serlo si no tienes cuidado: cierra todas las instancias del proceso sin distinguir cuál es cuál. En servidores, un killall java puede derribar múltiples servicios al mismo tiempo. Úsalo con cabeza.
• ¿Qué comando usar si Linux se congela?
  • Si la terminal sigue respondiendo, ejecuta killall nombre_proceso o kill -9 PID para forzar el cierre del programa problemático. Si la interfaz gráfica no responde, xkill te permite hacer clic sobre la ventana congelada para terminar el proceso asociado directamente.
• ¿Cómo matar el proceso de Discord en Linux?
  • Puedes usar killall Discord (con D mayúscula, ya que así aparece en el sistema) o localizar su PID con pgrep -l discord y luego ejecutar kill PID.

Conclusión

Dominar kill y killall te da control real sobre tu sistema Linux. Puedes resolver bloqueos, liberar recursos y seguir trabajando sin necesidad de reiniciar. La clave está en elegir el comando correcto para cada situación: kill cuando necesitas precisión quirúrgica sobre un proceso concreto, y killall cuando quieres cerrar todas las instancias de un programa de golpe. Combinados con ps aux, pgrep, top y htop, tienes en la terminal todas las herramientas que necesitas para gestionar procesos de forma segura y eficiente. Y recuerda: siempre empieza con SIGTERM y usa SIGKILL solo cuando no haya más remedio.