0:00:07.881,0:00:09.753
Você tem percebido[br]que o seu sistema

0:00:09.753,0:00:13.383
está se comportando[br]de uma maneira não comum.

0:00:13.383,0:00:17.211
Uma série de processos está[br]consumindo recursos desnecessários

0:00:17.211,0:00:19.624
e você precisa[br]tomar uma decisão.

0:00:20.624,0:00:23.928
Um dos comandos mais utilizados[br]para o envio de sinais a processos

0:00:23.928,0:00:25.791
é o comando "Kill".

0:00:25.791,0:00:27.935
Comando "kill",[br]do inglês "matar",

0:00:27.935,0:00:30.732
não necessariamente[br]mata os processos.

0:00:30.732,0:00:32.443
O correto é afirmar[br]que ele envia

0:00:32.443,0:00:34.973
um determinado sinal[br]para o processo.

0:00:34.973,0:00:38.106
Eu posso enviar um sinal[br]para o processo parar,

0:00:38.106,0:00:42.717
para o processo reiniciar,[br]para o processo ser morto,

0:00:42.717,0:00:45.781
para o processo[br]ser suspendido,

0:00:45.781,0:00:49.178
enfim, eu posso enviar[br]vários tipos de sinais

0:00:49.178,0:00:51.398
para um processo[br]utilizando o comando "kill".

0:00:52.571,0:00:55.634
Vamos dar uma olhada em todas[br]as opções que conseguimos explorar,

0:00:55.634,0:00:57.575
utilizando[br]o comando "kill".

0:00:57.575,0:01:02.048
Primeiramente, eu vou executar[br]o comando "kill -l".

0:01:02.817,0:01:05.698
Quando nós executamos[br]esse comando,

0:01:05.698,0:01:09.772
ele me dá uma lista de possíveis[br]sinais que eu posso enviar.

0:01:09.772,0:01:12.278
Detalhe importante:[br]o comando "kill" aceita

0:01:12.278,0:01:16.315
com que eu passe o sinal[br]tanto de forma numérica

0:01:16.315,0:01:20.397
quanto através do próprio[br]nome do sinal.

0:01:20.397,0:01:21.645
Aqui, nós vamos abordar

0:01:21.645,0:01:25.626
somente as principais opções[br]do comando "kill".

0:01:25.626,0:01:28.515
Se você tiver interesse[br]em obter mais detalhes,

0:01:28.515,0:01:32.362
é só você ler o manual[br]do "kill", o "man kill".

0:01:32.362,0:01:35.062
Toda vez que eu quiser[br]enviar um sinal para o processo,

0:01:35.062,0:01:39.270
eu tenho que saber[br]qual é o PID do processo.

0:01:39.270,0:01:42.373
Então, eu vou executar[br]aqui um processo.

0:01:42.373,0:01:47.044
Eu vou enviar esse processo[br]para o segundo plano, parando-o,

0:01:47.044,0:01:51.383
e, depois, eu vou enviar um outro[br]sinal para o processo com o "kill".

0:01:51.383,0:02:00.856
eu vou executar o seguinte comando:[br]grep -ri "linux" /

0:02:00.856,0:02:03.695
Eu estou procurando todas[br]as ocorrências da palavra Linux

0:02:03.695,0:02:08.066
em todos os arquivos a partir[br]da raiz, de forma recursiva.

0:02:08.066,0:02:10.028
Se eu der enter,[br]automaticamente,

0:02:10.028,0:02:12.971
ele vai mostrar[br]uma série de informações na tela.

0:02:12.971,0:02:14.283
Então, eu vou usar

0:02:15.328,0:02:16.976
esse comando

0:02:18.112,0:02:21.828
para que ele mande[br]o que encontrar

0:02:21.828,0:02:25.133
para dentro do diretório[br]/dev/null

0:02:27.362,0:02:29.336
Perceba que o comando[br]está executando,

0:02:29.336,0:02:32.192
porém ele está executando[br]em segundo plano.

0:02:32.192,0:02:36.264
Se der o comando [br]"ps aux | grep grep",

0:02:37.570,0:02:41.034
ele trouxe para mim o comando,[br]que está aqui.

0:02:41.034,0:02:44.053
Então, esse é o PID[br]do comando,

0:02:44.053,0:02:46.570
que é o número[br]que identifica o processo.

0:02:46.570,0:02:51.412
Se eu digitar o comando "jobs",[br]ele vai mostrar todos os processos

0:02:51.412,0:02:52.986
que eu executei.

0:02:52.986,0:02:57.384
Então, automaticamente,[br]tenho dois processos em execução.

0:02:57.384,0:02:59.153
Dois greps rodando.

0:02:59.153,0:03:00.403
Vamos imaginar[br]o seguinte:

0:03:00.403,0:03:02.994
se você digitar[br]o comando "jobs -l",

0:03:02.994,0:03:06.824
automaticamente, ele mostra[br]o PID do processo.

0:03:06.824,0:03:09.115
Lembre-se: para poder[br]executar o comando "kill",

0:03:09.115,0:03:11.696
eu tenho que saber[br]o PID do processo.

0:03:11.696,0:03:14.575
Vamos imaginar que eu queira[br]enviar um sinal

0:03:14.575,0:03:17.839
para esse comando[br]de PID 959.

0:03:17.839,0:03:20.415
Eu vou usar[br]o comando "kill "

0:03:20.415,0:03:22.224
Qual o sinal que eu[br]quero enviar?

0:03:22.224,0:03:25.914
Se nós dermos um "kill -l",[br]conseguimos ver todos os sinais.

0:03:25.914,0:03:29.049
Vamos imaginar que eu[br]quero mandar um "SIGTSTP",

0:03:29.049,0:03:32.287
que é o sinal[br]de parar o processo.

0:03:32.287,0:03:37.493
Eu dou um "kill",[br]posso usar a opção -20

0:03:37.493,0:03:40.830
e posso usar o PID 959.

0:03:40.830,0:03:41.809
Pronto.

0:03:41.809,0:03:44.317
Se nós digitarmos agora[br]o comando de "jobs -L",

0:03:44.317,0:03:46.933
perceba que o processo[br]está parado.

0:03:47.500,0:03:51.407
Esse processo ele não foi morto,[br]ele só foi parado automaticamente.

0:03:51.407,0:03:56.813
Eu consigo mandar um sinal[br]para poder continuar esse processo? Sim,

0:03:56.913,0:04:02.052
que o menos o sinal que eu vou utilizar e

0:04:02.118,0:04:04.821
seguir cont. Que é o 18.

0:04:04.821,0:04:09.059
Eu posso tanto colocar o -18[br]como eu posso colocar menos

0:04:09.159,0:04:14.231
seguir count[br]e colocar o número do PID nove cinco nove?

0:04:14.298,0:04:17.234
Pronto, se eu der o jobs menos ele,

0:04:17.234,0:04:20.704
o processo voltou a ser executado.

0:04:20.805,0:04:21.972
O que nós fizemos?

0:04:21.972,0:04:26.344
Nós pegamos um processo, enviamos um sinal[br]para ele com Quil para ele parar.

0:04:26.444,0:04:28.112
Esse processo parou.

0:04:28.112,0:04:32.016
Imagine que fosse um processo que estava[br]consumindo muito recurso na sua máquina

0:04:32.083,0:04:34.752
e depois nós demos um sinal

0:04:34.752,0:04:38.056
para ele continuar a execução normalmente.

0:04:38.123,0:04:43.728
Um outro sinal que a gente pode mandar[br]para o processo é o sinal para ele parar.

0:04:43.795,0:04:47.199
O sinal padrão de parada de processo[br]é o sinal

0:04:47.265,0:04:50.035
15 ou se Guilherme,

0:04:50.035,0:04:54.039
esse sinal permite com que eu[br]pare um processo de forma tranquila.

0:04:54.106,0:04:57.710
Sabe quando você dá, por exemplo,[br]o comando System CTL Stop

0:04:57.910,0:05:00.012
e o nome do serviço?

0:05:00.012,0:05:05.451
Ou você quer que um processo pare de forma[br]tranquila, sem ser parado abruptamente?

0:05:05.518,0:05:10.790
A opção padrão de parada de processo[br]é essa -15 ou seguinte.

0:05:10.857,0:05:13.860
Eu vou executar[br]agora na tela e vamos ver o que acontece

0:05:13.893,0:05:18.264
que o -15 é nove cinco nove que é o PID.

0:05:18.365,0:05:19.833
Pronto.

0:05:19.833,0:05:22.302
Se der um de obs menos ele,

0:05:22.302,0:05:25.605
ele está dizendo que o processo[br]foi terminado.

0:05:25.672,0:05:29.476
Processos terminados[br]não podem ser continuados, ou seja,

0:05:29.476,0:05:31.578
ele acabou de ser finalizado.

0:05:31.578,0:05:34.581
Se nós dermos novamente um de obs menos[br]ele, ele não

0:05:34.581,0:05:37.585
mais aparece na listagem[br]dos processos em execução.

0:05:37.618,0:05:42.490
Existe uma outra opção do comando kill,[br]que é a qual as pessoas associam

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

0:05:48.096,0:05:50.531
Ela manda um sinal chamado seguinte.

0:05:50.531,0:05:56.337
Ou seja, ela manda o processo[br]ser morto de forma abrupta.

0:05:56.438,0:06:00.408
Se você tiver algum arquivo aberto,[br]os kill não vai se importar.

0:06:00.475,0:06:03.478
Se tiver alguém usando esse arquivo,[br]ele não vai se importar,

0:06:03.478,0:06:07.449
ele simplesmente vai parar[br]abruptamente o processo.

0:06:07.516,0:06:11.353
Apesar dessa formato, desta informação[br]ser enviada direta para o processo,

0:06:11.420,0:06:15.791
isso pode ocasionar alguns problemas[br]graves de corrompimento de dados

0:06:15.858,0:06:18.761
no seu sistema,[br]como por exemplo, se você mandar

0:06:18.761,0:06:22.665
um sinal com -9 para um banco de dados,[br]eu vou executar

0:06:22.665,0:06:26.369
ele agora aqui no terminal[br]para vocês entenderem o poder que ele tem.

0:06:26.469,0:06:28.538
Vamos executar o comando de OBS menos ele.

0:06:28.538,0:06:29.872
Eu ainda tenho o meu processo.

0:06:29.872,0:06:34.143
Um outro processo do grep[br]executando com PID 09h30 cinco

0:06:34.244,0:06:37.480
vou dar um kill -9

0:06:37.547,0:06:39.449
nove meia cinco

0:06:39.449,0:06:41.618
e vou dar um de obs menos ele.

0:06:41.618,0:06:44.821
Perceba que agora o processo[br]não foi parado, ele foi morto,

0:06:45.055,0:06:48.292
então ele mandou um sinal[br]para matar o processo.

0:06:48.358,0:06:51.662
É possível matar vários processos ao mesmo[br]tempo?

0:06:51.762,0:06:55.132
Sim, nós vamos ver aqui[br]uma lista de processos

0:06:55.132,0:06:58.135
e vamos matá los todos com o comando kill.

0:06:58.169,0:07:01.172
Eu vou executar novamente o grep

0:07:01.372,0:07:04.709
menos erre.

0:07:04.809,0:07:07.211
A palavra Linux

0:07:07.211,0:07:11.416
na raiz dois

0:07:11.482,0:07:16.554
é maior que um, maior que barra dev

0:07:16.654,0:07:21.293
ba no mandando para segundo plano.

0:07:21.393,0:07:24.262
Pronto, vou rodar algumas outras vezes.

0:07:24.262,0:07:28.800
Como executar dez vezes esse comando?

0:07:28.901,0:07:34.974
Se nós dermos um de obs menos ele está lá.

0:07:35.040,0:07:39.044
Todos os pides dos processos[br]que estão rodando para você

0:07:39.044,0:07:42.315
finalizar todos os processos ao mesmo[br]tempo, a gente vai executar o seguinte

0:07:42.315,0:07:46.586
comando eu vou capturar todos os pides

0:07:46.686,0:07:49.689
e vou executar kill.

0:07:49.856,0:07:53.293
E aí podemos passar tanto -9 quanto -15.

0:07:53.293,0:07:57.330
Lembrando que -9 vai matar o processo[br]abruptamente e o -15

0:07:57.330,0:08:02.169
Ele vai somente parar o processo[br]de forma tranquila.

0:08:02.235,0:08:06.607
Vou usar o sinal -9,[br]que é o seguinte que eu

0:08:06.673,0:08:08.642
posso passar todos os pides

0:08:08.642,0:08:22.556
separado por espaço.

0:08:22.657,0:08:24.225
Perceba que realmente dá um trabalho.

0:08:24.225,0:08:27.195
Se eu tivesse 100 processos aqui rodando,[br]eu teria que passar ali

0:08:27.462,0:08:31.332
os 100 números dos pides.

0:08:31.399,0:08:35.036
Se eu der um de obs menos,[br]ele só ficou executando o processo

0:08:35.036,0:08:39.674
dez 37 que provavelmente eu pulei[br]ele aqui da lista.

0:08:39.741,0:08:48.217
Vamos aproveitar então e treinar por -15.

0:08:48.283,0:08:49.251
Pronto,

0:08:49.251,0:08:49.952
esse é o comando

0:08:49.952,0:08:53.188
que o comando usado para a gente[br]poder enviar um sinal para o processo.

0:08:53.355,0:08:56.292
Você pode mandar um sinal para ele[br]continuar,

0:08:56.292,0:08:58.527
pedir, suspender para ele reiniciar.

0:08:58.527,0:09:01.731
Tudo depende do quanto você precisa

0:09:01.797,0:09:06.202
que o sinal seja enviado e como você quer[br]que esse comando se comporte.

0:09:06.302,0:09:10.273
O comando kill permite matar processos[br]utilizando o PID, o Process

0:09:10.273,0:09:11.708
Identification.

0:09:11.708,0:09:14.811
Existem dois comandos[br]que facilitam muito a nossa vida

0:09:14.811,0:09:18.748
quando o objetivo é matar vários processos[br]ao mesmo tempo.

0:09:18.848,0:09:23.854
Esses comandos são pequenos, é o que o[br]ou o pequeno permite matar processos

0:09:23.854,0:09:27.758
utilizando o nome do processo,[br]assim como killall.

0:09:27.824,0:09:31.328
Então todos os sinais que eu enviei[br]para os processos usando kill

0:09:31.395,0:09:32.596
eu posso fazer também

0:09:32.596,0:09:37.568
com um comando pequeno e kill,[br]porém ao invés de eu passar o PID

0:09:37.635,0:09:38.936
eu passo

0:09:38.936,0:09:41.939
o nome do processo.

0:09:42.073,0:09:43.875
Vamos executar agora

0:09:43.875,0:09:46.677
eu vou gerar uma lista de processos[br]novamente

0:09:46.677,0:09:51.349
com o comando grep.

0:09:51.416,0:09:54.419
Cinco processos[br]foram gerados com esse comando grep

0:09:54.619,0:09:57.188
grep menos e linux barra

0:09:57.188,0:10:00.892
dois maior e um maior[br]que barra deve recomeçar

0:10:00.992,0:10:04.896
se nós dermos um de obs menos[br]ele, estão lá todos os processos,

0:10:05.130,0:10:07.966
todos os processos tem o nome de grep.

0:10:07.966,0:10:10.969
Nesse momento[br]eu vou executar o comando p kill

0:10:10.969,0:10:13.138
e eu posso usar todas as opções de sinais

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

0:10:16.642,0:10:21.714
Eu vou usar a opção -15 para parar[br]esses processos de forma natural

0:10:21.814,0:10:25.218
e ao invés de eu passar PID por PID,[br]como eu faria no que eu passo?

0:10:25.218,0:10:27.954
Simplesmente o nome do

0:10:27.954,0:10:30.290
comando que foi

0:10:30.290,0:10:33.927
executado, no caso aqui, o próprio grep.

0:10:34.027,0:10:35.028
Quando eu dou um enter,

0:10:35.028,0:10:38.865
ele termina todos os processos[br]com o nome grep.

0:10:38.932,0:10:42.969
Isso permite com que eu tenha muito mais[br]velocidade na execução do comando

0:10:42.969,0:10:48.408
quando eu quiser finalizar um processo[br]ou vários processos utilizando o nome.

0:10:48.475,0:10:52.246
O comando kill funciona de maneira[br]parecida com um comando pequeno.

0:10:52.312,0:10:57.384
Nós conseguimos matar diversos processos[br]utilizando o nome dos processos.

0:10:57.451,0:10:59.286
Eu executar agora novamente o grep

0:10:59.286,0:11:03.157
para que a gente possa visualizar isso[br]acontecendo dentro do sistema.

0:11:03.224,0:11:05.827
Eu vou executar agora[br]cinco vezes o comando grep

0:11:05.827,0:11:10.265
para que gerem os processos e a gente[br]possa utilizar o que o HAL para matá lo.

0:11:10.365,0:11:14.369
Uma, duas, três, quatro, cinco.

0:11:14.469,0:11:18.139
Se nós executarmos o comando de obs menos[br]ele está lá.

0:11:18.206,0:11:21.843
Cinco O processo de execução[br]O nome do processo é grep.

0:11:21.943,0:11:25.747
Eu vou usar o kill[br]para poder matar esses processos.

0:11:25.814,0:11:28.517
Vou utilizar os mesmo[br]sinais que eu uso no kill e no pq

0:11:28.517,0:11:33.088
eu vou colocar por exemplo[br]os ao -9 para matar o processo forçando.

0:11:33.188,0:11:37.092
E o comando que quero matar é o[br]todos os comandos que contem o nome grep.

0:11:37.159,0:11:41.063
Eu recebi uma mensagem[br]que o comando killall não foi encontrado.

0:11:41.130,0:11:43.633
Vamos instalá lo através do comando

0:11:43.633,0:11:46.836
apertei install ps misc.

0:11:46.903,0:11:55.345
Vou utilizar a opção menos y para ele[br]dizer sim para todos os questionamentos.

0:11:55.445,0:11:56.579
Pronto, uma vez instalado

0:11:56.579,0:12:00.116
parece me que ele trouxe para mim[br]o kill e ele

0:12:00.217,0:12:02.919
eu vou executar novamente[br]o comando kill ao -9

0:12:02.919,0:12:07.658
e automaticamente ele matou[br]todos os processos que tinham o nome grep

0:12:07.724,0:12:12.563
com esses três comandos kill pq eu e kill[br]nós podemos enviar diversos

0:12:12.563,0:12:18.169
sinais aos processos, podemos parar,[br]reiniciar, suspender, continuar.

0:12:18.235,0:12:22.473
Ou seja, você pode manipular os processos[br]conforme a sua necessidade

0:12:22.573,0:12:25.476
e se tornar ainda mais eficiente

0:12:25.476,0:12:28.813
na operação do terminal Linux,[br]utilizando o processo de.