LINUX

Cómo matar un proceso desde la terminal de Linux

matar un proceso desde la terminal de Linux

Todo lo que se ejecuta en el sistema operativo Linux se considera un proceso. Cuando un usuario ejecuta un programa o el sistema operativo Linux ejecuta un servicio del sistema, se creará un nuevo proceso.

Por lo general, los procesos terminarán cuando terminen sus tareas, o el usuario los obliga a terminar usando el mouse para hacer clic en «Cerrar» o presionando «Ctrl + C» en el teclado.

Sin embargo, podemos encontrar un comportamiento inesperado cuando un proceso cuelga y ocupa casi todos los recursos del sistema como CPU o RAM. Para liberar recursos, tenemos que terminar o «matar» manualmente ese proceso.

En este tutorial, veremos cómo matar un proceso en Linux.

El mecanismo del comando de matar

El nombre del comando ‘kill’ nos dice que se usa para detener inmediatamente un proceso en el sistema Linux. El comando ‘kill’ intentará finalizar los procesos que desea eliminar de la manera más elegante posible.

El comando ‘Kill’ envía una señal específica al proceso. La señal podría ser SIGTERM (Terminate) o SIGKILL (Kill Signal). La señal SIGTERM tiene un valor numérico de 15, la señal SIGKILL tiene un valor numérico de 9.

Por defecto, enviar una señal SIGTERM es la forma más segura de matar el proceso. Instruye al proceso para que finalice y les da a los programas o servicios tiempo para terminar las cosas antes de que se apaguen, como escribir en archivos de registro o cerrar conexiones abiertas que fueron creadas por el proceso.

Por otro lado, la señal SIGKILL es una forma insegura de matar un proceso porque termina el proceso sin guardar nada.

La señal SIGKILL es realmente efectiva cuando un usuario quiere matar un proceso que se está ejecutando obstinadamente.

Localizar los procesos en ejecución

Cada proceso en el sistema Linux es una instancia de un programa. Cada vez que el sistema operativo inicia un programa, se le asigna un PID único, que significa PAGproceso Identificaciónnúmero de identificación.

Como resultado, no podría haber dos procesos con el mismo PID en un sistema Linux porque el sistema operativo usa el ID de proceso para rastrear cada proceso.

Para matar un proceso, primero debemos especificar los detalles del proceso ejecutando ‘ps command’, ‘top’, ‘pidof’ o ‘pgrep’.

Más adelante en este tutorial, explicaré más sobre la forma de usar los comandos anteriores. Recuerde que cuando mata el proceso por su PID, solo se mata un proceso específico. Considerando que, matar el proceso por su nombre terminará todos los procesos en ejecución de un programa.

Mata un proceso por PID

Para ver una lista de todos los procesos en ejecución y el pid correspondiente, use ‘comando ps’:

$ ps aux

USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

root          1  0.0  0.3 159904  7152 ?        Ss   Thg 611   0:10 /sbin/init splash
root          2  0.0  0.0      0     0 ?        S    Thg 611   0:00 [kthreadd]
root          3  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [rcu_gp]
root          4  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [rcu_par_gp]
root          6  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [kworker/0:0H-kb]
root          9  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [mm_percpu_wq]
root         10  0.0  0.0      0     0 ?        S    Thg 611   0:02 [ksoftirqd/0]
root         11  0.0  0.0      0     0 ?        I    Thg 611   2:48 [rcu_sched]
root         12  0.0  0.0      0     0 ?        S    Thg 611   0:00 [migration/0]
root         13  0.0  0.0      0     0 ?        S    Thg 611   0:00 [idle_inject/0]
root         14  0.0  0.0      0     0 ?        S    Thg 611   0:00 [cpuhp/0]
root         15  0.0  0.0      0     0 ?        S    Thg 611   0:00 [cpuhp/1]
root         16  0.0  0.0      0     0 ?        S    Thg 611   0:00 [idle_inject/1]
root         17  0.0  0.0      0     0 ?        S    Thg 611   0:01 [migration/1]
root         18  0.0  0.0      0     0 ?        S    Thg 611   0:00 [ksoftirqd/1]
root         20  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [kworker/1:0H-kb]
root         21  0.0  0.0      0     0 ?        S    Thg 611   0:00 [kdevtmpfs]
root         22  0.0  0.0      0     0 ?        I<   Thg 611   0:00 [netns]
root         23  0.0  0.0      0     0 ?        S    Thg 611   0:00 [rcu_tasks_kthre]
root         24  0.0  0.0      0     0 ?        S    Thg 611   0:00 [kauditd]
...
comando ps aux
salida de comando auxiliar ps

Una vez que se determina la identificación del proceso, puede terminar el proceso usando el comando ‘kill’ seguido de su pid. Por ejemplo:

$ sudo kill <process id>

El comando anterior envía una señal SIGTERM al proceso y lo termina. Puede verificar si el proceso se ha cerrado correctamente ejecutando el comando:

$ ps aux | grep <process id>

Algunas cosas importantes a tener en cuenta:

  • Un usuario puede matar todos sus procesos.
  • Un usuario no puede matar procesos de otros usuarios.
  • Un usuario no puede matar un proceso que está ejecutando el sistema
  • La raíz puede matar procesos del sistema y procesos de cualquier usuario.

Puede ejecutar el comando kill con ‘sudo’ para matar un proceso como ‘root’.

Otra forma de ver una lista de los procesos en ejecución es usando el comando ‘top’:

$ top

top - 16:50:31 up 3 days, 53 min,  1 user,  load average: 0,00, 0,00, 0,00
Tasks: 257 total,   1 running, 186 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0,2 us,  0,3 sy,  0,0 ni, 99,5 id,  0,0 wa,  0,0 hi,  0,0 si,  0,0 st
KiB Mem :  2006008 total,  1209480 free,   443172 used,   353356 buff/cache
KiB Swap:   969960 total,   922100 free,    47860 used.  1403360 avail Mem 

   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND                                                                                 
    11 root      20   0       0      0      0 I   0,3  0,0   2:48.96 rcu_sched                                                                               
     1 root      20   0  159904   7152   5400 S   0,0  0,4   0:10.25 systemd                                                                                 
     2 root      20   0       0      0      0 S   0,0  0,0   0:00.03 kthreadd                                                                                
     3 root       0 -20       0      0      0 I   0,0  0,0   0:00.00 rcu_gp                                                                                  
     4 root       0 -20       0      0      0 I   0,0  0,0   0:00.00 rcu_par_gp                                                                              
     6 root       0 -20       0      0      0 I   0,0  0,0   0:00.00 kworker/0:0H-kb                                                                         
     9 root       0 -20       0      0      0 I   0,0  0,0   0:00.00 mm_percpu_wq                                                                            
    10 root      20   0       0      0      0 S   0,0  0,0   0:02.56 ksoftirqd/0                                                                             
    12 root      rt   0       0      0      0 S   0,0  0,0   0:00.89 migration/0                                                                             
    13 root     -51   0       0      0      0 S   0,0  0,0   0:00.00 idle_inject/0                                                                           
    14 root      20   0       0      0      0 S   0,0  0,0   0:00.00 cpuhp/0                                                                                 
    15 root      20   0       0      0      0 S   0,0  0,0   0:00.00 cpuhp/1                                                                                 
    16 root     -51   0       0      0      0 S   0,0  0,0   0:00.00 idle_inject/1                                                                           
    17 root      rt   0       0      0      0 S   0,0  0,0   0:01.09 migration/1                                                                             
    18 root      20   0       0      0      0 S   0,0  0,0   0:00.94 ksoftirqd/1                                                                             
    20 root       0 -20       0      0      0 I   0,0  0,0   0:00.00 kworker/1:0H-kb   
comando superior
comando superior mostrar pid

Como puede ver en la salida del comando superior, el PID del proceso está en la columna de la izquierda y el nombre del programa correspondiente está a la derecha.

Además, si desea obtener el PID de un proceso del que conoce su nombre, ejecute la siguiente línea de comando:

$ pidof <program-name>

Por ejemplo, para obtener el PID de un proceso tiene el nombre ‘netns’:

$ pidof netns
22

Aún más, si no conoce el nombre exacto del proceso, puede ejecutar el comando ‘pgrep’. Por ejemplo, para buscar todos los procesos que contienen «netn», ejecute el comando:

$ pgrep netn
22

A veces, puede encontrar un proceso que se cuelga y se niega a terminar, puede matar ese proceso enviando la señal SIGKILL con la opción -9

$ sudo kill -9 <process id>

Mata un proceso por su nombre

Esta sección explicará la forma de matar un proceso usando el nombre del proceso. Hay muchos comandos que podemos usar para matar un proceso por su nombre, como: ‘killall’ y ‘pkill’.

Usar el comando killall para matar un proceso si conoce el nombre exacto del proceso. Ejecute la línea de comando:

$ killall <process name>

Por ejemplo, para matar un proceso llamado «nginx», ejecute la línea de comando:

$ killall nginx

Si desea matar a la fuerza un proceso, envíe la señal SIGKILL a este proceso:

$ killall -9 nginx

Hay algunos otros escenarios de uso del comando ‘killall’. Por ejemplo:

Para matar un proceso que se ha estado ejecutando durante más de 10 minutos, ejecute la línea de comando:

$ killall -o 10m <process name> 

Para matar un proceso que se ha estado ejecutando durante menos de 10 minutos, ejecute:

$ killall -y 10m <process name>

A veces, no sabe el nombre exacto de un programa, solo conoce una parte del nombre, puede usar el comando ‘pkill’ para matar ese proceso. Aquí hay un ejemplo:

$ pkill ssh

Si hay otros procesos llamados ‘ssh-server’ o ‘ssh-agent’, el comando anterior ‘pkill’ también matará a ambos.

Conclusión

En este tutorial, aprendimos muchas formas de matar el proceso en Linux. Pasamos por los detalles de cómo usar el comando ‘kill’ y el comando ‘pkill’ para terminar un proceso por PID o por nombre.

Con la experiencia de usar el comando ‘kill’ y las prácticas prácticas anteriores, podría supervisar los procesos que se ejecutan en el sistema operativo.

Gracias por leer y deje su sugerencia en la sección de comentarios a continuación.

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba
Cerrar