Linux / Comando pkill: enviar sinais por nome e conferir os alvos

pkill envia um sinal aos processos que correspondem a um nome ou a outros critérios. Por padrão, envia SIGTERM, um pedido de término. Primeiro consulte os mesmos critérios com pgrep e confira os alvos: uma correspondência ampla pode atingir vários processos.

O guia de pgrep para pesquisar PIDs explica a seleção sem enviar sinais. No pkill, a seleção leva a uma ação real; conferir uma consulta anterior ajuda a reduzir enganos, mas não congela a lista de processos entre os dois comandos.

Sintaxe e significado do sinal

pkill [opções] padrão

Confira pkill --version, pkill --help e man pkill na instalação de destino. As opções deste artigo seguem procps-ng, o conjunto de utilitários que fornece essa implementação de pkill. Não suponha que outra implementação aceite as mesmas opções.

Um sinal é uma notificação ao processo. SIGTERM permite que a aplicação implemente um tratamento de término, mas ela pode capturá-lo, bloqueá-lo ou ignorá-lo. Enviar o sinal não garante que a limpeza terminou nem que os dados foram gravados. O manual de sinais do Linux descreve a ação padrão e as possibilidades de tratamento.

Consultar antes de enviar

Os exemplos com myworker pressupõem um processo de teste que você criou e tem autorização para encerrar. O nome é ilustrativo; não copie uma ação para um nome real sem confirmar todas as correspondências. Comece pela consulta:

pgrep -a -x myworker

Confira os identificadores de processo, ou PIDs, e as linhas de comando mostradas. -a acrescenta a linha de comando à saída de pgrep; -x exige correspondência com o nome inteiro. Se aparecer mais de um processo, a ação com os mesmos critérios poderá atingir todos eles, não apenas a primeira linha.

pgrep -a não exibe uma coluna de usuário. Quando a identidade importar, inclua um critério de usuário e confira também uma consulta como ps -p PID -o pid=,user=,comm=,args=, substituindo PID pelo identificador observado. O guia de ps explica esses campos.

Pedir o término pelo nome

Depois de confirmar que todos os processos selecionados são os alvos pretendidos, a forma básica é:

pkill -x myworker

Sem outro sinal especificado, esse comando usa SIGTERM. Ele não oferece uma pergunta de confirmação para cada correspondência. Normalmente não mostra uma lista de PIDs quando termina; o silêncio, por si só, não prova que todos os processos encerraram.

Na implementação documentada, o padrão é uma expressão regular estendida, uma regra de correspondência de texto. -x exige que ela corresponda ao campo inteiro, mas não transforma caracteres de expressão regular em texto literal. Nomes com pontos, colchetes ou outros caracteres especiais exigem atenção ao padrão e às aspas do shell.

Limitar pelo usuário efetivo

Quando o nome existe em mais de uma conta, é possível restringir o usuário:

pkill -u alice -x myworker

Substitua alice por uma conta existente e autorizada. -u seleciona pelo ID de usuário efetivo. Os critérios de usuário e nome precisam ser satisfeitos ao mesmo tempo. Consulte primeiro com pgrep -a -u alice -x myworker para manter os mesmos critérios da ação.

Selecionar a conta não muda a identidade de quem executa o comando nem concede permissão para enviar sinais a processos alheios. No Linux, essa permissão depende das identidades e dos privilégios envolvidos, conforme o manual de kill(2). Um problema de permissão deve ser investigado no contexto correto, sem ampliar os alvos por tentativa.

Prática restrita a um processo de teste

O exemplo completo abaixo exige Linux, Bash, pgrep e pkill de procps-ng e os utilitários cp, mktemp e sleep. Execute-o numa pasta de teste gravável, em um Bash sem set -e. Ele copia o executável sleep para uma pasta nova com o nome demo-worker e inicia uma espera de 30 segundos. Não use um script chamado demo-worker para substituir essa cópia: o nome observado do processo pode ser o do interpretador.

Os parênteses criam um sub-shell separado. A variável BASHPID fornece o PID desse Bash, usado em -P para limitar tanto a consulta quanto a ação aos seus filhos diretos. Aqui, esse contexto cria apenas um filho chamado demo-worker. A consulta é repetida por até dez tentativas para dar tempo ao início do executável; se não o encontrar, o bloco não envia sinal e espera o teste terminar naturalmente.

(
  for tool in pgrep pkill cp mktemp sleep; do
    command -v "$tool" >/dev/null || exit 1
  done
  sleep_bin=$(type -P sleep) || exit 1
  demo_dir=$(mktemp -d ./pkill-demo.XXXXXX) || exit 1
  cp -- "$sleep_bin" "$demo_dir/demo-worker" || exit 1
  demo_parent=$BASHPID
  "$demo_dir/demo-worker" 30 &
  demo_pid=$!

  found=0
  for attempt in 1 2 3 4 5 6 7 8 9 10; do
    if pgrep -a -P "$demo_parent" -x demo-worker; then
      found=1
      break
    fi
    sleep 0.1
  done
  if [ "$found" -ne 1 ]; then
    printf '%s\n' 'Processo de teste não encontrado; nenhum sinal enviado.' >&2
    wait "$demo_pid"
    exit 1
  fi

  pkill -TERM -P "$demo_parent" -x demo-worker
  signal_status=$?
  wait "$demo_pid"
  wait_status=$?
  pgrep -a -P "$demo_parent" -x demo-worker
  query_status=$?
  printf 'pkill=%s pgrep-final=%s wait=%s\n' \
    "$signal_status" "$query_status" "$wait_status"
)

A primeira consulta deve mostrar o PID e o caminho para demo-worker. No caso esperado em que SIGTERM encerra o sleep, a consulta final não encontra o filho e o resumo mostra pkill=0 pgrep-final=1 wait=143 no Bash. Esse é um resultado esperado para a prática, não uma saída medida nesta verificação. O shell também pode mostrar uma mensagem de término do trabalho.

O wait espera especificamente o filho criado e recolhe seu estado antes da consulta final. O estado 143 corresponde a término por SIGTERM nesse caso; se o sleep terminar naturalmente, seu estado é 0. Não execute o bloco com set -e: estados não zero fazem parte do resultado a examinar. A pasta de teste fica no local para inspeção; nenhuma alteração de serviço, usuário ou configuração é necessária.

A verificação disponível usou Bash 5.3.9 do Git para Windows. Pgrep e pkill não estavam instalados; as verificações de versão e ajuda de pkill retornaram 127. Os comandos originais e o bloco completo passaram pela análise de sintaxe, mas o exercício Linux, a cópia do executável e o envio de sinais não foram executados. Portanto, essa verificação não comprova o comportamento de seleção nem o término em Linux.

Opções e critérios

-P recebe o PID do pai e seleciona filhos diretos; não significa automaticamente todos os descendentes de uma árvore. Na prática acima, ele limita um cenário criado para o teste. Em um serviço real, relações de parentesco podem mudar e o gerenciador de serviços pode acompanhar os processos por outros critérios.

Conferir o resultado e os limites

Segundo o manual de pgrep, pkill e pidwait de procps-ng, estado 0 de pkill significa que pelo menos uma correspondência foi sinalizada com sucesso. Não garante sucesso para todos os alvos nem que eles terminaram. Estado 1 indica nenhuma correspondência ou nenhum alvo sinalizado; 2 indica erro de sintaxe e 3 indica erro fatal. Capture $? imediatamente após a ação, antes que outro comando o substitua, e confira a saída de erro.

Uma aplicação pode tratar SIGTERM, demorar na limpeza ou ser reiniciada por um supervisor. Se o processo reaparecer, confira o PID, o início e a política do serviço, em vez de repetir pkill indefinidamente. Para serviços administrados, prefira a operação de parada documentada pelo gerenciador do serviço e confira o resultado e os registros.

-f pode selecionar outros programas porque seus argumentos contêm o texto procurado. O próprio pkill é excluído, mas isso não exclui automaticamente shells, supervisores ou outras tarefas. A busca por nome também tem o limite de 15 caracteres descrito no manual; trocar para -f muda a seleção, por isso requer uma nova consulta com os mesmos critérios.

SIGKILL não pode ser capturado, bloqueado nem ignorado pelo processo, e não permite executar um tratador da aplicação para limpeza. Ele não é uma alternativa equivalente ao término normal. Antes de considerar uma ação forçada, confirme o alvo, o motivo da demora e o procedimento da aplicação; não há garantia de recuperar trabalho que não foi salvo.

Pergunta frequente

Qual é a diferença entre pkill e pgrep?

Pgrep consulta os processos que correspondem aos critérios; pkill envia um sinal às correspondências que pode sinalizar. Consultar primeiro ajuda a verificar os alvos, mas a lista pode mudar entre a consulta e a ação. Use os mesmos critérios e confira o resultado depois.