Phenquestions
Sistemas operacionais de multiprocessamento como Linux e BSDs empregam vários métodos para maximizar a utilização da CPU. Um processo é simplesmente um programa em execução. Uma vez que haverá mais de um processo Linux em execução em um determinado momento, o gerenciamento de processos no Linux é extremamente crucial. Os usuários costumam enfrentar problemas como limitação de recursos da CPU ao executar muitos programas. Situações como essa surgem quando a CPU não consegue lidar com o número crescente de processos. Embora isso não dependa inteiramente da potência de sua CPU, lidar com processos pendurados ou zumbis pode ser bastante frustrante. Para ajudá-lo a mitigar essas ocorrências, estamos delineando algumas maneiras padrão de eliminar esses processos.
Master Unresponsive Process Management no Linux
Você aprenderá várias maneiras de encerrar um processo Linux que não está respondendo de forma alguma. Se você estiver vindo do Windows, deve estar familiarizado com Ctrl + Alt + Delete. Da mesma forma, os usuários do Mac têm o método Command + Option + Escape para eliminar processos congelados. O Linux é muito mais versátil do que suas contrapartes e oferece mais de um método para lidar com processos mortos / sem resposta.
Métodos diferentes de matar um processo Linux morto
Descreveremos principalmente dois métodos para matar processos de zumbis. Usaremos o terminal Linux para o primeiro método. Para isso, primeiro precisamos identificar a id do processo. Uma vez obtido com sucesso, podemos usar este PID para matar o programa, enviando sinais específicos para aquele PID.
Você também aprenderá como executar tarefas de eliminação do Linux a partir da interface gráfica do usuário ou da janela X. Vamos alavancar o 'Monitor de Sistema' aplicativo disponível no Ubuntu para este. Embora este seja um aplicativo GNOME, ferramentas semelhantes estão disponíveis para outros ambientes de desktop Linux.
Encerrar um processo que não responde a partir da linha de comando
Existem várias ferramentas para encerrar um processo que não responde ou travado na linha de comando, incluindo mate, pkill, e Mate todos. Esses comandos funcionam enviando sinais específicos para esses processos que não respondem. Você vai precisar do ID do processo ou PID informações para que você possa enviar a eles o sinal de encerramento necessário.
O PID ou id do processo é um número único que identifica um processo. Eles são criados pelo kernel Linux durante o tempo de execução, e o planejador de processo controla suas atividades de CPU. Assim, sempre que você invocar um aplicativo, o kernel irá primeiro gerar os processos necessários e atribuir a eles esses valores PID exclusivos. Pode haver vários PIDs associados a um processo. Além disso, cada processo tem um único processo pai com um único PPID (ID do processo pai).
Então, se você pode descobrir este PPID, então você será capaz de enviar um sinal de kill usando programas projetados para esta finalidade. Abaixo, você aprenderá como verificar os processos em execução no Linux e identificar seus PPID no terminal.
Descubra as informações PPID
Você pode descobrir o PPID de um processo usando vários comandos de gerenciamento de processo no Linux, como pidof, pstree, e pgrep. Vamos examiná-los um por um e ver como obter o PID de um processo Linux.
Método 1: usando o comando ps
O comando ps no Linux exibe todos os processos em execução junto com outras informações relacionadas ao processo, como o PID no terminal. Podemos usar este comando para listar todos os processos e, em seguida, filtrar um processo específico usando comandos grep do Linux. Deve nos mostrar as informações de identificação do processo em que estamos interessados.
$ nano> / dev / null &
$ ps aux | grep "nano"
Primeiro, invocamos um editor de texto Linux em segundo plano. Então usamos o comando ps junto com o comando grep para descobrir o PPID deste editor. A saída pode conter vários IDs de processo, mas estamos interessados apenas no primeiro, pois é o nosso PPID. Também podemos usar o comando Linux awk para descobrir essas informações, conforme demonstrado abaixo.
$ ps aux | awk '/ nano / print $ 2'
Este comando é mais flexível, pois suprime todas as informações irrelevantes. Ele mostrará apenas as informações PPID que estamos procurando.
Método 2: usando o comando pstree
O comando pstree nos fornece uma visão em árvore de todos os processos em execução. Ele fornece uma visão gráfica da lista de tarefas do Linux a partir da janela do terminal. Você pode ver o PPID, bem como todas as informações PID de um processo usando este comando. Confira os exemplos abaixo para aprender como aproveitar o pstree para encontrar o PPID de um processo específico.
$ nano> / dev / null &
$ pstree -p | grep 'nano' $ pstree -p | awk '/ nano / print $ NF'
Primeiro, geramos um processo em segundo plano usando o primeiro comando. O segundo comando então recupera o PPID deste processo usando o comando grep no Linux. Finalmente, o terceiro comando nos mostra como recuperar este valor usando o comando awk.
Método 3: usando o comando pgrep
O comando pgrep é um dos comandos de gerenciamento de processo mais fáceis no Linux. Ele verifica a lista de todos os processos em execução e imprime o PPID de um determinado processo na saída padrão ou no terminal em nosso caso. Ele funciona executando correspondência de regex e é extremamente adequado para escrever scripts de shell do Linux.
$ nano> / dev / null &
$ pgrep 'nano'
Nós geramos o processo nano de maneira semelhante aos exemplos anteriores. Então nós obtivemos seu PPID usando o comando pgrep. Depois de obter esse valor, podemos executar o kill job do Linux com muita facilidade.
Método 4: usando o comando pidof
O comando pidof é outra maneira simples, mas útil de determinar o PPID de um processo Linux. Ele exibe o PPID e todos os outros PIDs associados a um processo. Confira o exame abaixo para ver como usar isso na prática.
$ nano> / dev / null &
$ pidof nano $ pidof -s nano
Ao usar o comando pidof para verificar os processos em execução no Linux, você frequentemente verá vários PIDs. Normalmente, nesses casos, o primeiro ou o último número é o PPID, dependendo se eles estão em ordem crescente ou decrescente. Você pode usar o -s opção de pidof para mitigar isso. Irá exibir apenas o valor PPID.
Método 5: usando o comando superior
O comando top fornece uma visão em tempo real de todos os processos em execução em sistemas operacionais tipo Unix. Você pode usar isso para exibir a lista de tarefas do Linux em seu terminal e descobrir as informações PID de um processo específico.
$ top
Use os seguintes comandos para recuperar o PPID de um processo específico da saída do comando top.
$ nano> / dev / null &
$ top -n1 -b | grep 'nano' $ top -n1 -b | awk '/ nano / print $ 1'
Como o top fornece saída em tempo real em vez de despejar dados estáticos no terminal, usamos o -n1 e -b opção de imprimir a saída estática. Então você pode recuperar as informações PPID usando o comando grep ou o comando awk no Linux.
Elimine o processo Linux sem resposta
Você pode usar qualquer um dos métodos acima para recuperar o PPID do processo que não responde. Depois de obter isso, é hora de encerrar o processo por completo. Existem vários comandos que nos permitem fazer isso, como mate, pkill, e Mate todos. Veremos como eles funcionam um por um nas seções a seguir.
Método 1: usando o comando kill
O comando kill é amplamente usado por administradores Linux devido à sua simplicidade e ações robustas. Leva o PID do processo e um sinal. O kernel mata / interrompe a execução do processo com base neste sinal. Você pode usar o próximo comando para ver todos os sinais disponíveis para o comando kill.
$ kill -l
Como você pode ver, o kill oferece 64 sinais diferentes. No entanto, discutiremos apenas dois deles neste guia. Estes são o sinal 9 (SIGKILL) e o sinal 15 (SIGTERM). SIGTERM ou sinal 15 é o método seguro de matar um processo que não responde. SIGKILL ou sinal 9, por outro lado, força mata um processo Linux.
$ kill -9 8631 $ kill -KILL 8631
Os comandos acima são equivalentes, e eles forçarão o encerramento do processo que possui o PID 8631. Esse é o PPID do processo 'nano' no meu sistema. Substitua-o pelo PID do processo que não responde em seu sistema.
$ kill -15 8631 $ kill -TERM 8631
Os comandos acima também são equivalentes e irão encerrar o processo normalmente. É por isso que pode levar algum tempo antes que o processo seja encerrado. Além disso, você pode precisar anexar sudo antes do comando kill se o processo pertencer a um usuário diferente.
Método 2: usando o comando pkill
O comando pkill é um dos comandos de gerenciamento de processo mais versáteis no Linux. Ele nos permite eliminar um processo que não responde com base em seu nome, PID, proprietário e outros atributos de tempo de execução. É uma ferramenta perfeita para usuários iniciantes ou pessoas que não estão familiarizadas com muitos comandos de terminal padrão.
$ pkill nano $ pkill 8631 $ pkill -e nano $ pkill -f nano
Você pode usar qualquer um dos comandos pkill acima para matar um zumbi / processo sem resposta no Linux. Use o -e opção se você quiser uma confirmação sobre o kill job do Linux. O comando pkill também permite que os usuários enviem sinais de terminação específicos.
Método 3: usando o comando killall
O comando killall permite que os usuários eliminem processos que não respondem com base em seus nomes. É mais fácil de usar, mas pode causar problemas se você não for cuidadoso. Uma vez que killall encerra processos com base em nomes, sempre há uma chance de você acabar matando um processo por acaso. Por exemplo, se houver diferentes versões do nano disponíveis em seu sistema, o primeiro exemplo irá matar todos eles.
$ killall nano $ killall --verbose nano $ killall --interactive nano $ killall --signal KILL nano
O primeiro exemplo mostra o uso básico do comando killall no Linux. O segundo comando irá relatar se o kill job foi bem sucedido ou não, e o terceiro comando irá pedir ao usuário uma confirmação antes de matar o processo. Por padrão, killall usa o sinal SIGTERM para matar processos. No entanto, você pode especificar o sinal manualmente, conforme mostrado no último exemplo.
Método 4: Usando One-Liners Práticos
A verdadeira beleza do Linux reside no fato de que permite aos usuários criar combinações de comandos sofisticadas com base em suas necessidades. Para demonstrar isso, delineamos algumas linhas simples na seção.
$ nano> / dev / null &
$ kill -9 $ (pgrep nano) $ ps aux | grep -e 'nano' | awk 'print $ 2' | xargs kill -9
No primeiro exemplo, usamos a interpolação de shell para passar o PID do processo 'nano' para o comando kill do Linux. O segundo exemplo utiliza vários comandos de terminal do dia a dia e redirecionamento de I / O para interromper o processo. Você pode fazer a curadoria de suas próprias linhas simples assim que se sentir confortável com o terminal Linux.
Método 5: matar vários processos usando scripts de shell do Linux
Às vezes, os usuários podem querer encerrar mais de um único processo. Podemos automatizar facilmente essas tarefas, escrevendo scripts de shell simples. Se você estiver interessado neste tópico, verifique nosso guia anterior sobre scripts de shell do Linux. O script a seguir irá recuperar o PPID dos processos que você deseja encerrar e, em seguida, encerrá-los usando sinais de encerramento.
$ nano proc-killer.sh
#!/ usr / bin / env bash para pro em "$ @" do pid = $ (pgrep $ pro | head -1) echo $ pid comm = "kill -9 $ pid" eval $ comm feito
Agora, salve este arquivo e adicione permissão de execução emitindo o comando abaixo.
$ chmod + x proc-killer.sh
Agora você pode passar a este script o nome dos processos que deseja encerrar.
$ ./ proc-killer.sh nano gedit vlc
Simplesmente substitua os argumentos pelos nomes dos processos Linux que não respondem em seu sistema.
Encerrar um processo sem resposta da GUI
Você também pode encerrar um processo que não responde na interface gráfica do usuário ou na janela X. Discutimos dois métodos para fazer isso na seção a seguir.
Método 1: usando o aplicativo xkill
Distribuições modernas de Linux utilizam a janela gráfica X para fornecer aos usuários uma experiência gráfica elegante. Existe uma ferramenta simples chamada xkill que permite aos usuários fechar uma janela GUI que não responde. Isso é possível porque, no Linux, a janela de título de um aplicativo é separada do próprio aplicativo.
Basta ir ao emulador de terminal Linux e digitar xkill. Ele vai transformar o cursor do mouse em um botão X, que pode ser usado para matar qualquer janela GUI.
$ xkill
Agora, tudo o que você precisa fazer é clicar na barra da janela do aplicativo que não responde, e ele será encerrado e desaparecerá instantaneamente.
Método 2: usando o aplicativo System Monitor no Ubuntu
A maioria das distribuições Linux convencionais vem com algum tipo de ferramenta de monitoramento GUI que permite aos usuários encerrar um processo Linux suspenso graficamente. Por exemplo, o aplicativo System Monitor no Ubuntu nos permitirá encerrar um processo que não responde de maneira intuitiva. Você pode simplesmente selecionar o processo morto da lista de processos e eliminá-lo clicando com o botão direito do mouse no processo e selecionando a opção kill.
Existem muitas outras alternativas para este aplicativo, e temos certeza de que você pode facilmente encontrar uma para sua distribuição ou ambiente de área de trabalho.
Reflexões finais
Como o gerenciamento de processos no Linux é muito versátil, os usuários costumam ficar frustrados ao lidar com processos que não respondem. É por isso que nossos editores delinearam todas as maneiras possíveis de encerrar um processo Linux morto neste guia. Depois de ler isso, você deve ser capaz de matar todos os processos que não respondem a partir da linha de comando ou da interface do usuário. Você também pode usar qualquer um dos nossos comandos de uma linha para lidar com esses incômodos no menor tempo possível. Além disso, você pode até mesmo matar mais de um único processo usando nosso script de shell simples. Com sorte, você obteve as informações que procurava em nosso guia.
