WEBVTT

00:00:07.881 --> 00:00:09.753
Você tem percebido
que o seu sistema

00:00:09.753 --> 00:00:13.383
está se comportando
de uma maneira não comum.

00:00:13.383 --> 00:00:17.211
Uma série de processos está
consumindo recursos desnecessários

00:00:17.211 --> 00:00:19.624
e você precisa
tomar uma decisão.

00:00:20.624 --> 00:00:23.928
Um dos comandos mais utilizados
para o envio de sinais a processos

00:00:23.928 --> 00:00:25.791
é o comando "Kill".

00:00:25.791 --> 00:00:27.935
Comando "kill",
do inglês "matar",

00:00:27.935 --> 00:00:30.732
não necessariamente
mata os processos.

00:00:30.732 --> 00:00:32.443
O correto é afirmar
que ele envia

00:00:32.443 --> 00:00:34.973
um determinado sinal
para o processo.

00:00:34.973 --> 00:00:38.106
Eu posso enviar um sinal
para o processo parar,

00:00:38.106 --> 00:00:42.717
para o processo reiniciar,
para o processo ser morto,

00:00:42.717 --> 00:00:45.781
para o processo
ser suspendido,

00:00:45.781 --> 00:00:49.178
enfim, eu posso enviar
vários tipos de sinais

00:00:49.178 --> 00:00:51.398
para um processo
utilizando o comando "kill".

00:00:52.571 --> 00:00:55.634
Vamos dar uma olhada em todas
as opções que conseguimos explorar,

00:00:55.634 --> 00:00:57.575
utilizando
o comando "kill".

00:00:57.575 --> 00:01:02.048
Primeiramente, eu vou executar
o comando "kill -l".

00:01:02.817 --> 00:01:05.698
Quando nós executamos
esse comando,

00:01:05.698 --> 00:01:09.772
ele me dá uma lista de possíveis
sinais que eu posso enviar.

00:01:09.772 --> 00:01:12.278
Detalhe importante:
o comando "kill" aceita

00:01:12.278 --> 00:01:16.315
com que eu passe o sinal
tanto de forma numérica

00:01:16.315 --> 00:01:20.397
quanto através do próprio
nome do sinal.

00:01:20.397 --> 00:01:21.645
Aqui, nós vamos abordar

00:01:21.645 --> 00:01:25.626
somente as principais opções
do comando "kill".

00:01:25.626 --> 00:01:28.515
Se você tiver interesse
em obter mais detalhes,

00:01:28.515 --> 00:01:32.362
é só você ler o manual
do "kill", o "man kill".

00:01:32.362 --> 00:01:35.062
Toda vez que eu quiser
enviar um sinal para o processo,

00:01:35.062 --> 00:01:39.270
eu tenho que saber
qual é o PID do processo.

00:01:39.270 --> 00:01:42.373
Então, eu vou executar
aqui um processo.

00:01:42.373 --> 00:01:47.044
Eu vou enviar esse processo
para o segundo plano, parando-o,

00:01:47.044 --> 00:01:51.383
e, depois, eu vou enviar um outro
sinal para o processo com o "kill".

00:01:51.383 --> 00:02:00.856
eu vou executar o seguinte comando:
grep -ri "linux" /

00:02:00.856 --> 00:02:03.695
Eu estou procurando todas
as ocorrências da palavra Linux

00:02:03.695 --> 00:02:08.066
em todos os arquivos a partir
da raiz, de forma recursiva.

00:02:08.066 --> 00:02:10.028
Se eu der enter,
automaticamente,

00:02:10.028 --> 00:02:12.971
ele vai mostrar
uma série de informações na tela.

00:02:12.971 --> 00:02:14.283
Então, eu vou usar

00:02:15.328 --> 00:02:16.976
esse comando

00:02:18.112 --> 00:02:21.828
para que ele mande
o que encontrar

00:02:21.828 --> 00:02:25.133
para dentro do diretório
/dev/null

00:02:27.362 --> 00:02:29.336
Perceba que o comando
está executando,

00:02:29.336 --> 00:02:32.192
porém ele está executando
em segundo plano.

00:02:32.192 --> 00:02:36.264
Se der o comando 
"ps aux | grep grep",

00:02:37.570 --> 00:02:41.034
ele trouxe para mim o comando,
que está aqui.

00:02:41.034 --> 00:02:44.053
Então, esse é o PID
do comando,

00:02:44.053 --> 00:02:46.570
que é o número
que identifica o processo.

00:02:46.570 --> 00:02:51.412
Se eu digitar o comando "jobs",
ele vai mostrar todos os processos

00:02:51.412 --> 00:02:52.986
que eu executei.

00:02:52.986 --> 00:02:57.384
Então, automaticamente,
tenho dois processos em execução.

00:02:57.384 --> 00:02:59.153
Dois greps rodando.

00:02:59.153 --> 00:03:00.403
Vamos imaginar
o seguinte:

00:03:00.403 --> 00:03:02.994
se você digitar
o comando "jobs -l",

00:03:02.994 --> 00:03:06.824
automaticamente, ele mostra
o PID do processo.

00:03:06.824 --> 00:03:09.115
Lembre-se: para poder
executar o comando "kill",

00:03:09.115 --> 00:03:11.696
eu tenho que saber
o PID do processo.

00:03:11.696 --> 00:03:14.575
Vamos imaginar que eu queira
enviar um sinal

00:03:14.575 --> 00:03:17.839
para esse comando
de PID 959.

00:03:17.839 --> 00:03:20.415
Eu vou usar
o comando "kill "

00:03:20.415 --> 00:03:22.224
Qual o sinal que eu
quero enviar?

00:03:22.224 --> 00:03:25.914
Se nós dermos um "kill -l",
conseguimos ver todos os sinais.

00:03:25.914 --> 00:03:29.049
Vamos imaginar que eu
quero mandar um "SIGTSTP",

00:03:29.049 --> 00:03:32.287
que é o sinal
de parar o processo.

00:03:32.287 --> 00:03:37.493
Eu dou um "kill",
posso usar a opção -20

00:03:37.493 --> 00:03:40.830
e posso usar o PID 959.

00:03:40.830 --> 00:03:41.809
Pronto.

00:03:41.809 --> 00:03:44.317
Se nós digitarmos agora
o comando de "jobs -L",

00:03:44.317 --> 00:03:46.933
perceba que o processo
está parado.

00:03:47.500 --> 00:03:51.407
Esse processo ele não foi morto,
ele só foi parado automaticamente.

00:03:51.407 --> 00:03:56.813
Eu consigo mandar um sinal
para poder continuar esse processo? Sim,

00:03:56.913 --> 00:04:02.052
que o menos o sinal que eu vou utilizar e

00:04:02.118 --> 00:04:04.821
seguir cont. Que é o 18.

00:04:04.821 --> 00:04:09.059
Eu posso tanto colocar o -18
como eu posso colocar menos

00:04:09.159 --> 00:04:14.231
seguir count
e colocar o número do PID nove cinco nove?

00:04:14.298 --> 00:04:17.234
Pronto, se eu der o jobs menos ele,

00:04:17.234 --> 00:04:20.704
o processo voltou a ser executado.

00:04:20.805 --> 00:04:21.972
O que nós fizemos?

00:04:21.972 --> 00:04:26.344
Nós pegamos um processo, enviamos um sinal
para ele com Quil para ele parar.

00:04:26.444 --> 00:04:28.112
Esse processo parou.

00:04:28.112 --> 00:04:32.016
Imagine que fosse um processo que estava
consumindo muito recurso na sua máquina

00:04:32.083 --> 00:04:34.752
e depois nós demos um sinal

00:04:34.752 --> 00:04:38.056
para ele continuar a execução normalmente.

00:04:38.123 --> 00:04:43.728
Um outro sinal que a gente pode mandar
para o processo é o sinal para ele parar.

00:04:43.795 --> 00:04:47.199
O sinal padrão de parada de processo
é o sinal

00:04:47.265 --> 00:04:50.035
15 ou se Guilherme,

00:04:50.035 --> 00:04:54.039
esse sinal permite com que eu
pare um processo de forma tranquila.

00:04:54.106 --> 00:04:57.710
Sabe quando você dá, por exemplo,
o comando System CTL Stop

00:04:57.910 --> 00:05:00.012
e o nome do serviço?

00:05:00.012 --> 00:05:05.451
Ou você quer que um processo pare de forma
tranquila, sem ser parado abruptamente?

00:05:05.518 --> 00:05:10.790
A opção padrão de parada de processo
é essa -15 ou seguinte.

00:05:10.857 --> 00:05:13.860
Eu vou executar
agora na tela e vamos ver o que acontece

00:05:13.893 --> 00:05:18.264
que o -15 é nove cinco nove que é o PID.

00:05:18.365 --> 00:05:19.833
Pronto.

00:05:19.833 --> 00:05:22.302
Se der um de obs menos ele,

00:05:22.302 --> 00:05:25.605
ele está dizendo que o processo
foi terminado.

00:05:25.672 --> 00:05:29.476
Processos terminados
não podem ser continuados, ou seja,

00:05:29.476 --> 00:05:31.578
ele acabou de ser finalizado.

00:05:31.578 --> 00:05:34.581
Se nós dermos novamente um de obs menos
ele, ele não

00:05:34.581 --> 00:05:37.585
mais aparece na listagem
dos processos em execução.

00:05:37.618 --> 00:05:42.490
Existe uma outra opção do comando kill,
que é a qual as pessoas associam

00:05:42.490 --> 00:05:48.096
ao fato de ele ser usado para matar,
processo que é a opção -9 a opção -9.

00:05:48.096 --> 00:05:50.531
Ela manda um sinal chamado seguinte.

00:05:50.531 --> 00:05:56.337
Ou seja, ela manda o processo
ser morto de forma abrupta.

00:05:56.438 --> 00:06:00.408
Se você tiver algum arquivo aberto,
os kill não vai se importar.

00:06:00.475 --> 00:06:03.478
Se tiver alguém usando esse arquivo,
ele não vai se importar,

00:06:03.478 --> 00:06:07.449
ele simplesmente vai parar
abruptamente o processo.

00:06:07.516 --> 00:06:11.353
Apesar dessa formato, desta informação
ser enviada direta para o processo,

00:06:11.420 --> 00:06:15.791
isso pode ocasionar alguns problemas
graves de corrompimento de dados

00:06:15.858 --> 00:06:18.761
no seu sistema,
como por exemplo, se você mandar

00:06:18.761 --> 00:06:22.665
um sinal com -9 para um banco de dados,
eu vou executar

00:06:22.665 --> 00:06:26.369
ele agora aqui no terminal
para vocês entenderem o poder que ele tem.

00:06:26.469 --> 00:06:28.538
Vamos executar o comando de OBS menos ele.

00:06:28.538 --> 00:06:29.872
Eu ainda tenho o meu processo.

00:06:29.872 --> 00:06:34.143
Um outro processo do grep
executando com PID 09h30 cinco

00:06:34.244 --> 00:06:37.480
vou dar um kill -9

00:06:37.547 --> 00:06:39.449
nove meia cinco

00:06:39.449 --> 00:06:41.618
e vou dar um de obs menos ele.

00:06:41.618 --> 00:06:44.821
Perceba que agora o processo
não foi parado, ele foi morto,

00:06:45.055 --> 00:06:48.292
então ele mandou um sinal
para matar o processo.

00:06:48.358 --> 00:06:51.662
É possível matar vários processos ao mesmo
tempo?

00:06:51.762 --> 00:06:55.132
Sim, nós vamos ver aqui
uma lista de processos

00:06:55.132 --> 00:06:58.135
e vamos matá los todos com o comando kill.

00:06:58.169 --> 00:07:01.172
Eu vou executar novamente o grep

00:07:01.372 --> 00:07:04.709
menos erre.

00:07:04.809 --> 00:07:07.211
A palavra Linux

00:07:07.211 --> 00:07:11.416
na raiz dois

00:07:11.482 --> 00:07:16.554
é maior que um, maior que barra dev

00:07:16.654 --> 00:07:21.293
ba no mandando para segundo plano.

00:07:21.393 --> 00:07:24.262
Pronto, vou rodar algumas outras vezes.

00:07:24.262 --> 00:07:28.800
Como executar dez vezes esse comando?

00:07:28.901 --> 00:07:34.974
Se nós dermos um de obs menos ele está lá.

00:07:35.040 --> 00:07:39.044
Todos os pides dos processos
que estão rodando para você

00:07:39.044 --> 00:07:42.315
finalizar todos os processos ao mesmo
tempo, a gente vai executar o seguinte

00:07:42.315 --> 00:07:46.586
comando eu vou capturar todos os pides

00:07:46.686 --> 00:07:49.689
e vou executar kill.

00:07:49.856 --> 00:07:53.293
E aí podemos passar tanto -9 quanto -15.

00:07:53.293 --> 00:07:57.330
Lembrando que -9 vai matar o processo
abruptamente e o -15

00:07:57.330 --> 00:08:02.169
Ele vai somente parar o processo
de forma tranquila.

00:08:02.235 --> 00:08:06.607
Vou usar o sinal -9,
que é o seguinte que eu

00:08:06.673 --> 00:08:08.642
posso passar todos os pides

00:08:08.642 --> 00:08:22.556
separado por espaço.

00:08:22.657 --> 00:08:24.225
Perceba que realmente dá um trabalho.

00:08:24.225 --> 00:08:27.195
Se eu tivesse 100 processos aqui rodando,
eu teria que passar ali

00:08:27.462 --> 00:08:31.332
os 100 números dos pides.

00:08:31.399 --> 00:08:35.036
Se eu der um de obs menos,
ele só ficou executando o processo

00:08:35.036 --> 00:08:39.674
dez 37 que provavelmente eu pulei
ele aqui da lista.

00:08:39.741 --> 00:08:48.217
Vamos aproveitar então e treinar por -15.

00:08:48.283 --> 00:08:49.251
Pronto,

00:08:49.251 --> 00:08:49.952
esse é o comando

00:08:49.952 --> 00:08:53.188
que o comando usado para a gente
poder enviar um sinal para o processo.

00:08:53.355 --> 00:08:56.292
Você pode mandar um sinal para ele
continuar,

00:08:56.292 --> 00:08:58.527
pedir, suspender para ele reiniciar.

00:08:58.527 --> 00:09:01.731
Tudo depende do quanto você precisa

00:09:01.797 --> 00:09:06.202
que o sinal seja enviado e como você quer
que esse comando se comporte.

00:09:06.302 --> 00:09:10.273
O comando kill permite matar processos
utilizando o PID, o Process

00:09:10.273 --> 00:09:11.708
Identification.

00:09:11.708 --> 00:09:14.811
Existem dois comandos
que facilitam muito a nossa vida

00:09:14.811 --> 00:09:18.748
quando o objetivo é matar vários processos
ao mesmo tempo.

00:09:18.848 --> 00:09:23.854
Esses comandos são pequenos, é o que o
ou o pequeno permite matar processos

00:09:23.854 --> 00:09:27.758
utilizando o nome do processo,
assim como killall.

00:09:27.824 --> 00:09:31.328
Então todos os sinais que eu enviei
para os processos usando kill

00:09:31.395 --> 00:09:32.596
eu posso fazer também

00:09:32.596 --> 00:09:37.568
com um comando pequeno e kill,
porém ao invés de eu passar o PID

00:09:37.635 --> 00:09:38.936
eu passo

00:09:38.936 --> 00:09:41.939
o nome do processo.

00:09:42.073 --> 00:09:43.875
Vamos executar agora

00:09:43.875 --> 00:09:46.677
eu vou gerar uma lista de processos
novamente

00:09:46.677 --> 00:09:51.349
com o comando grep.

00:09:51.416 --> 00:09:54.419
Cinco processos
foram gerados com esse comando grep

00:09:54.619 --> 00:09:57.188
grep menos e linux barra

00:09:57.188 --> 00:10:00.892
dois maior e um maior
que barra deve recomeçar

00:10:00.992 --> 00:10:04.896
se nós dermos um de obs menos
ele, estão lá todos os processos,

00:10:05.130 --> 00:10:07.966
todos os processos tem o nome de grep.

00:10:07.966 --> 00:10:10.969
Nesse momento
eu vou executar o comando p kill

00:10:10.969 --> 00:10:13.138
e eu posso usar todas as opções de sinais

00:10:13.138 --> 00:10:16.575
que nós vimos no kill -9, -15.

00:10:16.642 --> 00:10:21.714
Eu vou usar a opção -15 para parar
esses processos de forma natural

00:10:21.814 --> 00:10:25.218
e ao invés de eu passar PID por PID,
como eu faria no que eu passo?

00:10:25.218 --> 00:10:27.954
Simplesmente o nome do

00:10:27.954 --> 00:10:30.290
comando que foi

00:10:30.290 --> 00:10:33.927
executado, no caso aqui, o próprio grep.

00:10:34.027 --> 00:10:35.028
Quando eu dou um enter,

00:10:35.028 --> 00:10:38.865
ele termina todos os processos
com o nome grep.

00:10:38.932 --> 00:10:42.969
Isso permite com que eu tenha muito mais
velocidade na execução do comando

00:10:42.969 --> 00:10:48.408
quando eu quiser finalizar um processo
ou vários processos utilizando o nome.

00:10:48.475 --> 00:10:52.246
O comando kill funciona de maneira
parecida com um comando pequeno.

00:10:52.312 --> 00:10:57.384
Nós conseguimos matar diversos processos
utilizando o nome dos processos.

00:10:57.451 --> 00:10:59.286
Eu executar agora novamente o grep

00:10:59.286 --> 00:11:03.157
para que a gente possa visualizar isso
acontecendo dentro do sistema.

00:11:03.224 --> 00:11:05.827
Eu vou executar agora
cinco vezes o comando grep

00:11:05.827 --> 00:11:10.265
para que gerem os processos e a gente
possa utilizar o que o HAL para matá lo.

00:11:10.365 --> 00:11:14.369
Uma, duas, três, quatro, cinco.

00:11:14.469 --> 00:11:18.139
Se nós executarmos o comando de obs menos
ele está lá.

00:11:18.206 --> 00:11:21.843
Cinco O processo de execução
O nome do processo é grep.

00:11:21.943 --> 00:11:25.747
Eu vou usar o kill
para poder matar esses processos.

00:11:25.814 --> 00:11:28.517
Vou utilizar os mesmo
sinais que eu uso no kill e no pq

00:11:28.517 --> 00:11:33.088
eu vou colocar por exemplo
os ao -9 para matar o processo forçando.

00:11:33.188 --> 00:11:37.092
E o comando que quero matar é o
todos os comandos que contem o nome grep.

00:11:37.159 --> 00:11:41.063
Eu recebi uma mensagem
que o comando killall não foi encontrado.

00:11:41.130 --> 00:11:43.633
Vamos instalá lo através do comando

00:11:43.633 --> 00:11:46.836
apertei install ps misc.

00:11:46.903 --> 00:11:55.345
Vou utilizar a opção menos y para ele
dizer sim para todos os questionamentos.

00:11:55.445 --> 00:11:56.579
Pronto, uma vez instalado

00:11:56.579 --> 00:12:00.116
parece me que ele trouxe para mim
o kill e ele

00:12:00.217 --> 00:12:02.919
eu vou executar novamente
o comando kill ao -9

00:12:02.919 --> 00:12:07.658
e automaticamente ele matou
todos os processos que tinham o nome grep

00:12:07.724 --> 00:12:12.563
com esses três comandos kill pq eu e kill
nós podemos enviar diversos

00:12:12.563 --> 00:12:18.169
sinais aos processos, podemos parar,
reiniciar, suspender, continuar.

00:12:18.235 --> 00:12:22.473
Ou seja, você pode manipular os processos
conforme a sua necessidade

00:12:22.573 --> 00:12:25.476
e se tornar ainda mais eficiente

00:12:25.476 --> 00:12:28.813
na operação do terminal Linux,
utilizando o processo de.