Às vezes, finalizar um processo é a única solução viável. Apesar da conotação agressiva, “matar” um processo significa simplesmente forçar o seu encerramento. Veja como realizar essa ação através da linha de comando no Linux ou macOS.
O que é um Processo?
Processos são programas em execução, como seu navegador, atividades em segundo plano relacionadas ao seu ambiente de trabalho, e serviços do sistema Linux.
Podemos categorizar processos em dois grupos:
Processos de primeiro plano: são aqueles iniciados diretamente pelo usuário, seja em uma janela de terminal ou através de um aplicativo gráfico.
Processos em segundo plano: são iniciados automaticamente, sem interação direta com o usuário, executando tarefas como serviços e daemons, sem exibir resultados ou esperar comandos.
Metaforicamente, se os processos de primeiro plano são os atores no palco, os processos de segundo plano são a equipe técnica nos bastidores.
Quando um processo apresenta comportamento irregular, pode causar sobrecarga na CPU, consumo excessivo de RAM, ou entrar em loops computacionais, tornando-se não responsivo. Aplicativos gráficos podem ignorar cliques do mouse, enquanto aplicações de terminal podem deixar de retornar o prompt.
A Necessidade de Intervenção
Forçar um processo a encerrar, ou “matá-lo”, é essencial quando este se torna não responsivo.
O Linux oferece os comandos `kill`, `pkill` e `killall` para essa finalidade, aplicáveis a processos gráficos ou de linha de comando, sejam eles de primeiro plano ou segundo plano.
O Comando `kill`
Para utilizar o `kill`, é necessário conhecer o ID do processo (PID) a ser finalizado. O comando `ps` auxilia na identificação do PID.
Para exibir todos os processos, use a opção `-e` do comando `ps`. É aconselhável utilizar o `less` para facilitar a visualização da saída. Digite `ps -e | less` e pressione Enter.
ps -e | less
Uma lista de processos será exibida. Utilize `/` para buscar para frente e `?` para buscar para trás dentro do `less`.
Para refinar a busca e identificar o processo desejado, canalize a saída de `ps` para o `grep`, especificando o nome ou parte dele.
ps -e | grep shutter
Com o PID do processo em mãos, utilize-o como argumento no comando `kill`. Para finalizar o processo ‘shutter’, identificado no exemplo anterior com o PID 2099, digite:
kill 2099
O `kill` é silencioso, não oferece feedback se a ação for bem-sucedida.
O Comando `pkill`
O `pkill` permite finalizar um processo ou vários, baseando-se no nome. O PID não é necessário. Basta fornecer um termo de busca que o `pkill` utilizará para encontrar processos correspondentes.
Como medida de segurança, use o comando `pgrep` antes do `pkill`. O `pgrep`, também baseado em um termo de busca, lista os PIDs dos processos correspondentes sem emitir sinal de encerramento. Isso garante que você refine a busca antes de finalizar processos. Ambos os comandos, `pkill` e `pgrep`, tratam o termo de pesquisa de forma idêntica, tanto que compartilham a mesma página de manual.
Considere um processo com “subq” no nome. O comando `ps -u dave | grep subq` revela que “subq” corresponderá a esse processo específico.
ps -u dave | grep subq
Suponha que o usuário só saiba que o processo contém “subq”. O `pgrep` verifica se há apenas uma correspondência para o termo, que é então usado pelo `pkill`.
pgrep subq
pkill subq
É possível finalizar múltiplos processos simultaneamente com `pkill`. O usuário pode usar `pgrep` para verificar quantos processos do Chrome estão ativos, e então finalizá-los todos com `pkill`, confirmando com `pgrep` que todos foram removidos.
pgrep chrome
pkill chrome
pgrep chrome
Para distinguir entre processos com o mesmo nome, utilize a opção `-f` (linha de comando) do `pgrep`. Por exemplo, para diferenciar dois processos `ping`, utilize aspas para delimitar o parâmetro da linha de comando:
pgrep -f "ping 192.168.4.22"
pkill -f "ping 192.168.4.22"
O Comando `killall`
Atenção: Em sistemas Solaris e OpenIndiana, `killall` finaliza todos os processos do usuário. Se executado como root, ou com `sudo`, reinicie o sistema. Este comportamento foi confirmado na versão mais recente do OpenIndiana Hipster 2018.10.
O comando `killall` funciona de maneira similar ao `pkill`, com uma diferença essencial: exige o nome exato do processo, não aceitando correspondências parciais.
O nome completo do processo deve ser fornecido, como demonstrado abaixo:
killall shutt
killall shutter
A opção `-y` (mais novo que) finaliza processos iniciados há menos tempo que o período especificado. O período é definido por um número seguido de:
s (segundos)
m (minutos)
h (horas)
d (dias)
w (semanas)
M (meses, com “M” maiúsculo)
y (anos)
Para encerrar um processo chamado `ana` recém-iniciado, e manter instâncias anteriores em execução, use:
killall -y 2m ana
A opção `-o` (mais antigo que) finaliza processos em execução por mais tempo que o período especificado. Para finalizar conexões ssh em execução por mais de um dia:
killall -o 1d sshd
Cautela ao Utilizar os Comandos
Estes comandos permitem identificar e finalizar processos problemáticos de forma precisa e segura.
Tenha cautela. Certifique-se de que o processo a ser finalizado é o correto. Verifique novamente para garantir que você não finalizará o processo errado. Prossiga com a finalização apenas quando estiver seguro.