Você tem percebido que o seu sistema
está se comportando de uma maneira não comum.
Uma série de processos está consumindo recursos desnecessários
e você precisa tomar uma decisão.
Um dos comandos mais utilizados para o envio de sinais a processos
é o comando "kill".
Comando "kill", do inglês "matar",
não necessariamente mata os processos.
O correto é afirmar que ele envia
um determinado sinal para o processo.
Eu posso enviar um sinal para o processo parar,
para o processo reiniciar, para o processo ser morto,
para o processo ser suspendido,
enfim, eu posso enviar vários tipos de sinais
para um processo utilizando o comando "kill".
Vamos dar uma olhada em todas as opções que conseguimos explorar,
utilizando o comando "kill".
Primeiramente, eu vou executar o comando "kill -l".
Quando nós executamos esse comando,
ele me dá uma lista de possíveis sinais que eu posso enviar.
Detalhe importante: o comando "kill" aceita
com que eu passe o sinal tanto de forma numérica
quanto através do próprio nome do sinal.
Aqui, nós vamos abordar
somente as principais opções do comando "kill".
Se você tiver interesse em obter mais detalhes,
é só você ler o manual do "kill", o "man kill".
Toda vez que eu quiser enviar um sinal para o processo,
eu tenho que saber qual é o PID do processo.
Então, eu vou executar aqui um processo.
Eu vou enviar esse processo para o segundo plano, parando-o,
e, depois, eu vou enviar um outro sinal para o processo com o "kill".
Eu vou executar o seguinte comando:
"grep menos ri, espaço, aspas duplas, linux, aspas duplas, barra".
Eu estou procurando todas as ocorrências da palavra Linux
em todos os arquivos a partir da raiz, de forma recursiva.
Se eu der enter, automaticamente,
ele vai mostrar uma série de informações na tela.
Então, eu vou usar
esse comando
para que ele mande o que encontrar
para dentro do diretório "barra dev barra null".
Perceba que o comando está executando,
porém ele está executando em segundo plano.
Se der o comando "ps aux | grep grep",
ele trouxe para mim o comando, que está aqui.
Então, esse é o PID do comando,
que é o número que identifica o processo.
Se eu digitar o comando "jobs", ele vai mostrar todos os processos
que eu executei.
Então, automaticamente, tenho dois processos em execução.
Dois greps rodando.
Vamos imaginar o seguinte:
se você digitar o comando "jobs -l",
automaticamente, ele mostra o PID do processo.
Lembre-se: para poder executar o comando "kill",
eu tenho que saber o PID do processo.
Vamos imaginar que eu queira enviar um sinal
para esse comando de PID 959.
Eu vou usar o comando "kill espaço".
Qual o sinal que eu quero enviar?
Se nós dermos um "kill -l", conseguimos ver todos os sinais.
Vamos imaginar que eu quero mandar um "SIGTSTP",
que é o sinal de parar o processo.
Eu dou um "kill", posso usar a opção -20
e posso usar o PID 959.
Pronto.
Se nós digitarmos agora o comando de "jobs -l",
perceba que o processo está parado.
Esse processo não foi morto, ele só foi parado
Automaticamente, eu consigo mandar um sinal
para poder continuar esse processo?
Sim.
"kill" menos o sinal que eu vou utilizar,
que é SIGCONT, que é o 18.
Eu posso tanto colocar o -18, como eu posso colocar -SIGCONT,
e colocar o número do PID, 959.
Pronto, se eu der o "jobs -l", o processo voltou a ser executado.
O que nós fizemos?
Pegamos um processo, enviamos um sinal com "kill" para ele parar.
Esse processo parou.
Imagine que fosse um processo
que estava consumindo muito recurso na sua máquina.
E, depois, nós demos um sinal
para ele continuar a execução normalmente.
Um outro sinal que podemos mandar para o processo
é o sinal para ele parar.
O sinal padrão de parada de processo
é o sinal 15 ou SIGTERM.
Esse sinal permite com que eu pare o processo de forma tranquila.
Sabe quando você dá, por exemplo,
o comando "systemctl stop" e o nome do serviço?
Ou você quer que um processo pare de forma tranquila,
sem ser parado abruptamente?
A opção padrão de parada de processo é essa: -15 ou SIGTERM.
Eu vou executar agora na tela e vamos ver o que acontece.
"kill -15 959", que é o PID.
Pronto.
Se der um "jobs -l", estará dizendo que o processo foi terminado.
Processos terminados não podem ser continuados,
ou seja, ele acabou de ser finalizado.
Se nós dermos novamente um "jobs -l",
ele não mais aparece na listagem dos processos em execução.
Existe uma outra opção do comando "kill",
que é o que as pessoas associam
ao fato dele ser usado para matar processos,
que é a opção -9
Ela manda um sinal chamado SIGKILL,
ou seja, ela manda o processo ser morto de forma abrupta.
Se você tiver algum arquivo aberto, o "kill" não vai se importar.
Se alguém estiver usando esse arquivo, ele não vai se importar.
Ele simplesmente vai parar abruptamente o processo.
Apesar desta informação ser enviada diretamente para o processo,
isso pode ocasionar alguns problemas graves
de corrompimento de dados no seu sistema,
como, por exemplo, se você mandar
um sinal com -9 para um banco de dados.
Eu vou executá-lo agora, aqui no terminal,
para vocês entenderem o poder que ele tem.
Vamos executar o comando "jobs -l".
Eu ainda tenho um outro processo do grep executando
com o PID 965.
Vou dar um "kill -9 965".
E vou dar um "jobs -l".
Perceba que, agora, o processo não foi parado, ele foi morto.
Então, ele mandou um sinal para matar o processo.
É possível matar vários processos ao mesmo tempo?
Sim.
Nós vamos ver aqui uma lista de processos e vamos matá-los,
todos com o comando "kill".
Eu vou executar novamente o "grep -ri,
a palavra linux na raiz,
dois e,
maior que um, maior que barra dev, barra null",
mandando para segundo plano.
Pronto, vou rodar algumas outras vezes.
Vou executar 10 vezes esse comando.
Se nós dermos um "jobs -l", está lá.
Todos os PIDs dos processos que estão rodando
Para você finalizar todos os processos ao mesmo tempo,
a gente vai executar o seguinte comando:
eu vou capturar todos os PIDs e vou executar,
"kill" e aí, podemos passar tanto -9 quanto -15.
Lembrando que -9 vai matar o processo abruptamente
e o -15 vai somente parar o processo de forma tranquila.
Vou usar o sinal -9, que é o SIGKILL,
e posso passar todos os PIDs, separados por espaço.
Perceba que realmente dá trabalho.
Se tivesse 100 processos rodando,
eu teria que passar os 100 números dos PIDs.
Se eu der um "jobs -l", só ficou executando o processo 1037,
que, provavelmente, eu o pulei aqui da lista.
Vamos aproveitar, então, e treinar o -15.
Pronto.
Esse é o comando "kill",
comando usado para podermos enviar um sinal para o processo.
Você pode mandar um sinal para ele parar, continuar,
para ele suspender, para ele reiniciar.
Tudo depende do quanto você precisa que o sinal seja enviado
e como você quer que esse comando se comporte.
O comando "kill" permite matar processos
utilizando o PID, o "Process Identification".
Existem dois comandos que facilitam muito a nossa vida
quando o objetivo é matar vários processos ao mesmo tempo.
Esses comandos são "PKILL" e "KILLALL".
O PKILL permite matar processos utilizando o nome do processo,
assim como KILLALL.
Então, todos os sinais que enviei para os processos usando kill,
eu posso fazer também com os comandos PKILL e KILLALL,
porém, ao invés de eu passar o PID,
eu passo o nome do processo.
Vamos executar agora.
Eu vou gerar uma lista de processos novamente com o comando grep.
Cinco processos foram gerados com esse comando grep:
"grep menos ri, linux, barra 2, e comercial, maior que 1,
maior que barra dev, barra null, e comercial".
Se nós dermos um "jobs -l", estão lá todos os processos.
Todos os processos tem o nome de "grep".
Nesse momento, eu vou executar o comando "pkill"
e posso usar todas as opções de sinais
que vimos no "kill", -9, -15.
Eu vou usar a opção -15 para parar esses processos de forma natural.
E, ao invés de eu passar PID por PID,
como eu faria no "kill" eu passo simplesmente o nome
do comando que foi executado, no caso aqui, o próprio "grep".
Quando eu dou um enter,
ele termina todos os processos com o nome "grep".
Isso permite com que eu tenha muito mais velocidade
na execução do comando quando quiser finalizar um processo
ou vários processos utilizando o nome.
O comando KILLALL funciona
de maneira parecida com o comando PKILL.
Nós conseguimos matar diversos processos
utilizando o nome dos processos.
Eu vou executar, agora, novamente o "grep"
para que possamos visualizar isso acontecendo dentro do sistema.
Eu vou executar agora 5 vezes o comando "grep"
para que gerem os processos
e a gente possa utilizar o KILLALL para matá-lo.
1, 2, 3, 4, 5.
Se nós executarmos o comando "jobs -l", está lá,
5 processos de execução.
O nome do processo é "grep".
Eu vou usar o "killall" para poder matar esses processos.
Vou utilizar os mesmos sinais que eu uso no "kill" e no "pkill".
Vou usar, por exemplo, o -9 para matar o processo forçando.
E o comando que quero matar
são todos os comandos que contêm o nome "grep".
Recebi uma mensagem que o comando "killall"
não foi encontrado.
Vamos instalá-lo através do comando "apt install psmisc".
Vou utilizar a opção menos y
para ele dizer sim para todos os questionamentos.
Pronto, uma vez instalado o "psmisc",
ele trouxe para mim o "killall".
E eu vou executar novamente o comando "killall -9"
e, automaticamente, ele matou
todos os processos que tinham o nome "grep".
Com esses três comandos, "kill", "pkill" e "killall",
nós podemos enviar diversos sinais aos processos.
Podemos parar, reiniciar, suspender, continuar.
Ou seja, você pode manipular os processos
conforme a sua necessidade
e se tornar ainda mais eficiente
na operação do terminal Linux, utilizando processo.