Gerenciamento de Processos Linux na Prática - Controle de Jobs, pkill e nice

2025-01-11 Tempo de leitura: Cerca de 12 min Dificuldade: Intermediário+

Construindo sobre o padrão de decisão "observar, verificar, parar" do artigo básico, este guia prático cobre:

• Alternativas a matar (execução em background, nice)
• Operar em múltiplos processos de uma vez (pkill, killall)
• Lidar com erros (Operation not permitted, etc.)

O Que Você Vai Aprender

• Uma sequência de decisão para lidar com processos: background, reduzir prioridade, depois parar
• Como usar Ctrl+Z / bg / fg para controle de jobs sem encerrar processos
• Como pkill e killall diferem e por que você deve verificar com pgrep primeiro
• Como nice e renice reduzem a prioridade de CPU em vez de matar processos pesados
• Como diagnosticar e corrigir erros "Operation not permitted" de kill e pkill

O Padrão de Decisão Prático

Quando um Processo Atrapalha, Pense Nesta Ordem

Antes de recorrer ao kill, percorra esta sequência:

1. Posso mover para o background? (Se eu só preciso do terminal)
2. Posso reduzir a prioridade? (Se só está usando muita CPU)
3. Se precisa ser parado, comece com TERM

"Matar" é apenas uma entre muitas opções.

Mantenha Rodando: Execução em Background

Conclusão: Use & para background; adicione nohup quando o processo deve sobreviver a desconexão SSH.

Iniciar em Background Desde o Início

$ long_command &

Adicionar & no final roda o comando em background.

Continuar Após Desconexão SSH

$ nohup long_command &

Com nohup, o processo continua rodando após o logout. A saída padrão é automaticamente gravada em nohup.out. Para especificar o destino da saída explicitamente:

$ nohup long_command > output.log 2>&1 &

Controle de Jobs: Ctrl+Z / bg / fg

Conclusão: Ctrl+Z suspende; bg retoma em background; fg traz de volta; jobs lista todos.

Use isso quando quiser "pausar um comando em execução e usar o terminal."

Fluxo Básico

# 1. Suspender o comando em execucao
Ctrl+Z

# 2. Retomar em background
$ bg

# 3. Ou trazer de volta ao foreground
$ fg

Quando Você Tem Múltiplos Jobs

# Verificar lista de jobs
$ jobs
[1]-  Stopped     vim file.txt
[2]+  Running     ./script.sh &

# Operar por numero do job
$ fg %1    # Trazer vim para o foreground

Ponto de Decisão Chave

• Ctrl+Z = Suspender (processo ainda está vivo)
• Ctrl+C = Tentar encerrar (envia SIGINT)

Se você só quer seu terminal de volta, Ctrl+Z --> bg mantém tudo rodando sem parar o processo.

Operações Multi-Processo: pkill / killall

Conclusão: Execute pgrep -l antes de pkill ou killall -- correspondência parcial vs exata importa.

Quando múltiplos processos compartilham o mesmo nome, especificar PIDs um por um é tedioso.

pkill: Operar por Nome

# Enviar SIGTERM para todos os processos chamados python
$ pkill python

# Matar forcadamente (ultimo recurso)
$ pkill -9 python

killall: Também Opera por Nome

$ killall python

# Verificar alvos antecipadamente
$ pgrep -l python
1234 python3
5678 python

Reduza a Velocidade: nice / renice

Conclusão: nice -n 10 inicia com baixa prioridade; renice +10 -p PID reduz a prioridade de um processo em execução.

Em vez de "matar" um processo que usa muita CPU, reduza sua prioridade para deixar outras tarefas rodarem primeiro.

nice: Definir Prioridade ao Iniciar

# Rodar com baixa prioridade (numero maior = prioridade menor)
$ nice -n 10 ./heavy_script.sh

renice: Alterar Prioridade de Processo em Execução

# Reduzir prioridade do PID 1234
$ renice +10 -p 1234

Faixa de Valores Nice

Nota: Números menores significam prioridade maior.

Situações onde nice/renice é eficaz:

• Um script de backup está rodando em background, mas você quer priorizar outro trabalho
• Um processo de build está pesado, mas você não quer pará-lo
• Você quer definir baixa prioridade para jobs batch noturnos desde o início

Ajuste de prioridade é eficaz para processos que você não pode reiniciar.

Lidando com Erros: Operation not permitted

Conclusão: Operation not permitted: verifique o dono do processo com ps aux antes de sudo kill.

O que fazer quando kill ou pkill retorna "Operation not permitted."

Causa e Solução

$ kill 1234
bash: kill: (1234) - Operation not permitted

Principais Causas Deste Erro

1. Tentando parar processo de outro usuário
2. Tentando parar um processo do sistema (iniciado pelo root)

Solução

# Primeiro, verifique o dono do processo
$ ps aux | grep 1234

# Se nao e seu processo, voce precisa de sudo
$ sudo kill 1234

Cenários do Mundo Real

Conclusão: Quatro cenários: a ferramenta certa é Ctrl+Z/bg, pkill, renice ou nohup para cada um.

Cenário 1: Precisa do Terminal Enquanto vim Está Aberto

Ctrl+Z       # Suspender vim
$ bg         # Mover para background (vim fica suspenso)
$ fg         # Retornar ao vim apos outro trabalho

Cenário 2: Múltiplos Processos Python Rodando Descontrolados

# 1. Verificar alvos
$ pgrep -l python
1234 python3
5678 python3

# 2. Enviar SIGTERM para todos
$ pkill python

# 3. Esperar alguns segundos, depois matar forcadamente apenas se ainda estiverem rodando
$ pgrep python && pkill -9 python

Cenário 3: Build Está Pesado mas Não Pode Ser Parado

# Encontrar o PID do processo de build
$ pgrep -l make
1234 make

# Reduzir sua prioridade
$ renice +15 -p 1234

Cenário 4: Processo Precisa Continuar Após Desconexão SSH

# Iniciar com nohup desde o inicio
$ nohup ./long_script.sh > log.txt 2>&1 &

# Ou separar um job em execucao
$ disown %1

Resumo

Quando um Processo Atrapalha

1. Só precisa do terminal --> Ctrl+Z --> bg
2. Só está usando muita CPU --> renice para reduzir prioridade
3. Precisa ser parado --> kill (SIGTERM)
4. Ainda não para --> kill -9 (último recurso)

"Matar" deve ser sua última escolha.

Próximas Leituras

• Gerenciamento de Processos (Básico) -- O padrão de decisão ps / top / kill
• Shell Scripting Básico -- Variáveis, condicionais e loops
• Comandos Essenciais do Linux