vimeo.com/.../919134074

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.