fbpx

Saber como parar, colocar em segundo plano e até saber qual processo está exaurindo os recursos do host são importantes para qualquer administrador.

Tarefas como verificar os processos que estão a executar, mudar a prioridade de execução e terminar os processos são exigidas para qualquer administrador Linux.

É bem verdade que o Kernel do Linux tem uma capacidade excelente para trabalhar com processos sem intervenção do usuário. Mas às vezes é preciso que o root intervenha e termine um processo que esteja comportando de forma egoísta e exaurindo os recursos da máquina.

Este controle de processos é especialmente importante porque o Linux é um sistema multitarefa, multiusuário e multiprocessado.

O conceito de multitarefa significa que o Linux é capaz de executar diversos programas e serviços ao mesmo tempo de forma preemptiva.

Se tivermos apenas um processador central no computador com Linux, o sistema fará o escalonamento (rodízio) dos processos de forma tão eficiente que o usuário terá a impressão de que ele pode executar mais de um programa ao mesmo tempo.

E o Linux ainda possui a capacidade de gerenciar os processos de forma eficaz com o multiprocessamento real quando temos mais de um processador central envolvido.

O Pai de todos os processos

Relembrando que, quando o computador com o Linux é ligado, o sistema imediatamente procura no setor de boot do disco rígido o gerenciador de boot. No Linux gerenciadores mais comuns são o Grub e Grub 2. Eles são responsáveis pela carga do Kernel na memória.

Nos sistemas baseados em System V, após a carga do Kernel, este inicia um processo especial chamado init. Este processo é o pai de todos os processos e responsável pelo restante da carga do boot do Linux e seus serviços.

Nos sistemas baseados em Systemd o, após a carga do kernel, este inicia um processo especial chamado systemd. Este processo é o pai de todos os processos e reponsável pelo restante da carga do boot do Linux e seus serviços.

Depois da carga do boot, o init – ou o systemd – chama outro programa especial chamado getty, que é responsável pela autenticação dos usuários e inicia o processo de shell.

Este conceito de hierarquia de processos é importante para você entender o restante.

Sinais: a forma como os processos conversam entre sí e com o kernel

Cada processo no Linux fica à escuta de sinais.

Estes sinais são utilizados pelo Kernel, por outros processos ou por usuário para avisar a um determinado processo sobre algum evento em particular.

O guru de UNIX W. Richard Stevens descreve os sinais como interrupções de software.

Quando um sinal é enviado para um processo ele toma uma determinada ação dependendo do valor que este sinal carrega.

Cada sinal tem um nome exclusivo e um valor numérico.

Vejamos alguns valores e suas ações:

O Linux possui mais de 30 sinais definidos. A maioria é utilizada pelo Kernel e alguns pelos usuários. Veja os mais importantes.

TABELA – Sinais mais importantes

Sinal Valor Numérico Ação
HUP 1 Hang-Up ou desligamento. Este sinal é utilizado automaticamente quando você  desconecta de uma sessão ou fecha um terminal. Ele também é utilizado por processos servidores para invocar a releitura do arquivo de configuração.
KILL 9 Terminar o processo incondicionalmente de forma rápida e drástica. Este tipo de sinal pode deixar arquivos abertos e bases de dados corrompidas. Deve ser utilizado caso o processo pare de responder ou em uma emergência.
TERM 15 Termina o processo de forma elegante, possiblitando que ele feche arquivos e execute suas rotinas de fim de execução.
TSTP 20 Termina a execução para continuar depois. Este sinal é enviado automaticamente quando utilizamos as teclas ctrl-z. É utilizado para colocar o processo em segundo plano.

O entendimento de sinais é importante para sabermos como o sistema interage com os processos em execução.

Controle de Processos

Como outros sistemas operacionais completos, o Linux possibilita que coloquemos processos em segundo plano de execução (background).

Para que um processo execute em segundo plano, é preciso que ele não espere por nenhuma ação do usuário, como por exemplo esperar por um subcomando. Neste estado o processo se comunicará com o usuário através dos sinais.

Processos em segundo plano

Basicamente para colocarmos qualquer processo em segundo plano de execução, basta adicionarmos o caractere “&” no final da linha de comando que executará o processo:

$ find / -name *.conf > lista_arquivos_configuracao.txt &

O comando find será executado em segundo plano e sua saída será direcionada para o arquivo lista_arquivos_configuracao.txt.

Prioridade de Execução

O Kernel do Linux possui como uma de suas atividades críticas o escalonador de processos.

Este escalonador é um algoritmo especial que coloca em fila todos os processos em execução e decide qual processo irá ser executado e durante quanto tempo.

O escalonador é o que permite que o computador possa executar mais de um processo em concorrência, dividindo a CPU em fatias de tempo de execução.

A implementação do escalonador é tão importante que ela é o que realmente faz a diferença nos sistemas operacionais modernos.

O Linux permite que o usuário interfira na prioridade de execução dos processos liberando mais ou menos tempo de CPU.

A lista de prioridades pode ser vista com o comando ps –lax na columa PRI.

Quanto maior for o número da PRIoridade, mais tempo de CPU o processo tem e mais importante ele é. Quanto menor o número, menos tempo de CPU e menor importância.

Vejamos alguns comandos básicos para gerência de processos:

Comando ps

Uso:

$ ps [opções]

O comando ps gera uma lista com todos os processos em execução e seus atributos.

As opções mais frequentes são:

  • -a: Mostra os processos em execução de todos os usuários. Normalmente ele mostra somente os processos pertencentes ao usuário que executou o ps;
  • -u: Mostra a lista de processos incluindo o nome dos usuários donos dos processos e início das execuções, percentual de CPU utilizada, percentual de memória utilizada e terminal associado;
  • -x: Mostra a lista de processos que não têm um terminal associado a ele. Útil para visualizar processos servidores (daemons);
  • f: Mostra os processos em forma de árvore. Muito útil para identificarmos a relação de processo pai e filho entre os processos em execução.

Veja o help do comando ps para mais opções.

Exemplos:

Comando pstree

Uso:

$ pstree [opções]

O comando pstree irá mostrar toda a árvore de processos desde o init até o último processo em execução. É similar ao comando ps –auxf. Ele é útil para entendermos a hierarquia dos processos no Linux.

Além das opções abaixo, o pstree poderá mostrar a hierarquia pertencente a um usuário ou de um processo específico através do seu PID.

  • -a: Esta opção mostra a linha de comando utilizada para iniciar os processos;
  • -c: Desabilita a função de mesclar os processos idênticos no mesmo nível de hierarquia;
  • -G: Utiliza o formato VT100 para mostrar as linhas entre os processos no lugar dos caracteres de teclado;
  • -h: Destaca os processos ligados ao terminal no exato momento;
  • -p: Inclui o PID dos processos na listagem.

Exemplo:

Se você quiser ver os processos em execução de uma forma dinâmica, como o “Tarefas” do Windows, o Linux tem o comando top:

Comando top

Uso:

$ top [opções]

O comando top mostra os processos em execução como o comando ps, mas atualizando a tela. Este recurso é útil para monitorarmos como um ou mais processos agem no sistema. Este comando também ordena os processos que utilizam mais CPU no TOPo da tela.

As opções mais utilizadas são:

  • -b: Executar em modo batch ou arquivo em lote. É utilizada para direcionarmos a saída do comando para outro processo ou para um arquivo;
  • -d n: Determina o tempo das atualizações da tela em n segundos. O padrão é cinco segundos;
  • -n num: Mostra o número de vezes na tela as atualizações dos processos em execução e depois termina. Útil para ser utilizado com a opção –b;
  • -q: Executar com atualizações em tempo real. Esta opção deve ser utilizada com cautela, pois pode consumir uma grande quantidade de cpu;
  • -u: Monitora os processos em execução de um determinado usuário;
  • -p: Monitora um determinado processo identificado pelo seu PID. Mais de um processo pode ser definido com esta opção.
  • O comando top ainda pode suportar alguns comandos que alteram o seu comportamento durante a sua execução. São eles:
  • Z: Muda o esquema de cores do top. Para que esta opção esteja ativa é necessário que o terminal suporte ANSI;
  • F: Adiciona colunas com mais opções de monitoramento dos processos;
  • u: Mostra os processos de um determinado usuário;
  • k: Termina (kill) com um determinado processo;
  • r: Muda a prioridade de execução do processo (renice);
  • R: Muda a ordem dos processos de acordo com a utilização da CPU;
  • q: Sai do modo interativo do top.

Agora que você já sabe listar os processos, é hora de aprender a parar os processos em execução com os comandos kill e killall:

Comando kill

Uso:

$ kill [–sinal] PID

O comando kill envia sinais para os processos. Ele é usado geralmente para terminar a execução de processos identificados pelo seu PID.

Se nenhum sinal específico for passado como parâmetro, o kill irá enviar o sinal TERM (15) para terminar o processo de forma elegante.

Muito chato matar processos um a um com o kill. Quer matar todos ? Use a metralhadora do killall 😀

Comando killall

Uso:

# killall [–sinal] NOME_DO_PROCESSO

O comando killall envia sinais para os processos e recebe como parâmetro não o PID do processo, mas seu nome.

Ele é usado geralmente para terminar a execução de processos que possuem diversos processos filhos executando ao mesmo tempo.

Se nenhum sinal específico for passado como parâmetro, o killall irá enviar o sinal TERM (15) para terminar o processo de forma elegante.

É importante que você entenda a diferença dos comandos kill e killall. O primeiro envia sinais para um ou mais processos identificados pelo PID. O segundo envia sinais para todos os processos na fila de execução que possuem um determinado nome.

Os sinais enviados pelo kill e pelo killall podem ser passados pelo nome ou pelo número inteiro correspondente.

uhhh! Tem zumbi no Linux. Walking-dead 😀

É possível, dentro de uma hierarquia de processos, que um determinado processo filho termine por algum motivo inesperado, e o processo pai se torne um processo zoombie ou defunto (defunct).

Os processos zoombie não podem ser terminados com o comando kill, porque eles já não existem mais.

Isso acontece porque cada processo criado recebe um lugar na tabela de processos do Kernel. Quando ele termina, seu lugar na tabela do Kernel recebe o resultado da sua execução. O resultado da execução é retido na tabela até alguém consultá-lo quando, então, é removido da tabela.

O estado do processo é chamado de “zumbi” quando o mesmo termina e seu resultado ainda não foi retirado da tabela do Kernel.

Outra possibilidade especial é quando um processo qualquer que criou novos processos filhos que executam debaixo de sua hierarquia termine inesperadamente.

Neste caso, os processos filhos perdem o seu processo pai e são adotados pelo processo init (PID 1) que é o pai de todos os processos. Observe a hierarquia entre os processos com o comando pstree –c –p.

Estas duas situações descritas não são normais e podem ser ocasionadas por bugs nos programas.

Vamos ver agora uma mistura da kill com grep: o comando pkill:

Comando pkill

Uso:

# pkill [expressão]

O comando pkill é análogo ao comando killall. Ele pode enviar sinais para os processos e recebe como parâmetro uma expressão ou nome do processo.

Ele é usado geralmente para terminar a execução de processos que possuem diversos processos filhos executando ao mesmo tempo.$ pkill mysqld

O pkill mata… já o pgrep, é uma mistura de ps com grep:

Comando pgrep

Uso:

# pgrep [expressão]

O comando pgrep permite que se procure por expressões na lista de processos em execução e retorna o PID do processo em questão.

Quer saber como alterar a prioridade dos processos em execução? Veja este post.

Se quiser aprender como colocar os processos em segundo plano, veja este post também.

Quer saber se uma certificação vale a pena ? Saiba porque os salários são bons, e porque as empresas estão procurando profissionais de Linux.

Você vai ententer que os benefícios superam de longe o sacrifício.

E se você já se decidiu, veja nosso Guia de Certificação.

E se quer saber onde fazer as provas, consulte a lista de cidade.

Se quiser saber o idioma das provas, veja esse post.

Aprenda muito mais sobre Linux em nosso curso online. Você pode fazer a matrícula aqui com trial de 7 dias grátis. Se você já tem uma conta, pode acessar aqui.

Gostou? Compartilhe 🙂

Trabalhando com processos no Linux
Classificado como:                                                

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Esse site utiliza o Akismet para reduzir spam. Aprenda como seus dados de comentários são processados.