Encontre e mate um processo em uma linha usando bash e regex

Muitas vezes preciso matar um processo durante a programação.

A maneira que eu faço agora é:

[~]$ ps aux | grep 'python csp_build.py' user 5124 1.0 0.3 214588 13852 pts/4 Sl+ 11:19 0:00 python csp_build.py user 5373 0.0 0.0 8096 960 pts/6 S+ 11:20 0:00 grep python csp_build.py [~]$ kill 5124 

Como posso extrair o id do processo automaticamente e matá-lo na mesma linha?

Como isso:

 [~]$ ps aux | grep 'python csp_build.py' | kill  

No bash , você deve ser capaz de fazer:

 kill $(ps aux | grep '[p]ython csp_build.py' | awk '{print $2}') 

Detalhes sobre o seu funcionamento são os seguintes:

  • O ps fornece a lista de todos os processos.
  • O grep filtra que baseado na sua string de busca, [p] é um truque para impedir que você pegue o próprio processo do grep .
  • O awk apenas fornece o segundo campo de cada linha, que é o PID.
  • A construção $(x) significa executar x então, pegar sua saída e colocá-la na linha de comando. A saída desse pipeline ps dentro dessa construção acima é a lista de IDs de processo, então você acaba com um comando como kill 1234 1122 7654 .

Aqui está uma transcrição mostrando em ação:

 pax> sleep 3600 & [1] 2225 pax> sleep 3600 & [2] 2226 pax> sleep 3600 & [3] 2227 pax> sleep 3600 & [4] 2228 pax> sleep 3600 & [5] 2229 pax> kill $(ps aux | grep '[s]leep' | awk '{print $2}') [5]+ Terminated sleep 3600 [1] Terminated sleep 3600 [2] Terminated sleep 3600 [3]- Terminated sleep 3600 [4]+ Terminated sleep 3600 

e você pode ver isso terminando todos os dormentes.


Explicando o bit do grep '[p]ython csp_build.py' com mais detalhes:

Quando você sleep 3600 & seguido por ps -ef | grep sleep Quando você ps -ef | grep sleep , você tende a ter dois processos com o sleep , o sleep 3600 e o grep sleep (porque ambos sleep neles, isso não é ciência de foguetes).

No entanto, ps -ef | grep '[s]leep' ps -ef | grep '[s]leep' não cria um processo com sleep nele, ele cria grep '[s]leep' e aqui está um pouco complicado: o grep não o encontra porque está procurando pela expressão regular “any caractere da class de caractere [s] (que é s ) seguido por leep .

Em outras palavras, ele está procurando por um sleep mas o processo grep '[s]leep' é o grep '[s]leep' que não tem sleep .

Quando eu fui mostrado isso (por alguém aqui no SO), eu imediatamente comecei a usá-lo porque

  • é um processo a menos que adicionar | grep -v grep | grep -v grep ; e
  • é elegante e sorrateiro, uma combinação rara 🙂

se você tiver pkill,

 pkill -f csp_build.py 

Se você quiser somente grep contra o nome do processo (em vez da lista completa de argumentos), então deixe off -f .

Um forro:

 ps aux | grep -i csp_build | awk '{print $2}' | xargs sudo kill -9 
  • Imprimir a coluna 2: awk '{print $2}'
  • sudo é opcional
  • Execute kill -9 5124 , kill -9 5373 etc (mate -15 é mais gracioso, mas um pouco mais lento)

Bônus:

Eu também tenho 2 funções de atalho definidas no meu .bash_profile (~ / .bash_profile é para osx, você tem que ver o que funciona para a sua máquina * nix).

  1. p palavra-chave
    • lista todos os processos contendo palavras-chave
    • uso, por exemplo: p csp_build , p python etc

código bash_profile:

 # FIND PROCESS function p(){ ps aux | grep -i $1 | grep -v grep } 
  1. palavra-chave ka
    • Todos os processos que possuem esta palavra-chave
    • uso, por exemplo: ka csp_build , ka python etc
    • nível de kill opcional, por exemplo: ka csp_build 15 , ka python 9

código bash_profile:

 # KILL ALL function ka(){ cnt=$( p $1 | wc -l) # total count of processes found klevel=${2:-15} # kill level, defaults to 15 if argument 2 is empty echo -e "\nSearching for '$1' -- Found" $cnt "Running Processes .. " p $1 echo -e '\nTerminating' $cnt 'processes .. ' ps aux | grep -i $1 | grep -v grep | awk '{print $2}' | xargs sudo kill -klevel echo -e "Done!\n" echo "Running search again:" p "$1" echo -e "\n" } 

Tente usar

 ps aux | grep 'python csp_build.py' | head -1 | cut -d " " -f 2 | xargs kill 
 killall -r regexp -r, --regexp 

Interpretar o padrão de nome do processo como uma expressão regular estendida.

Você pode usar apenas pkill '^python*' para matar o processo regex.

Se você quiser ver o que vai matar ou encontrar antes de matar, basta usar pgrep -l '^python*' onde -l produz também o nome do processo. Se você não quiser usar o pkill , use apenas:

pgrep '^python*' | xargs kill

você pode fazer isso com awk e backtics

 ps auxf |grep 'python csp_build.py'|`awk '{ print "kill " $2 }'` 

$ 2 na coluna 2 do awk prints, e o backtics executa a instrução impressa.

Mas uma solução muito mais limpa seria para o processo python armazenar seu ID de processo em / var / run e, em seguida, você pode simplesmente ler esse arquivo e eliminá-lo.

Use o pgrep – disponível em várias plataformas:

 kill -9 `pgrep -f cps_build` 

pgrep -f retornará todos os PIDs com coincidência “cps_build”

Minha tarefa foi matar tudo correspondente regexp que é colocado no diretório específico (após os testes de selenium nem tudo parou). Isso funcionou para mim:

 for i in `ps aux | egrep "firefox|chrome|selenium|opera"|grep "/home/dir1/dir2"|awk '{print $2}'|uniq`; do kill $i; done 

Para matar processo por palavra-chave midori , por exemplo:

kill -SIGTERM $(pgrep -i midori)

Um método usando apenas awk (e ps ):

 ps aux | awk '$11" "$12 == "python csp_build.py" { system("kill " $2) }' 

Usando o teste de igualdade de strings, evito a correspondência desse processo em si.

 ps -o uid,pid,cmd|awk '{if($1=="username" && $3=="your command") print $2}'|xargs kill -15 

Dê -f para pkill

 pkill -f /usr/local/bin/fritzcap.py 

o caminho exato do arquivo .py é

 # ps ax | grep fritzcap.py 3076 pts/1 Sl 0:00 python -u /usr/local/bin/fritzcap.py -c -d -m 

Eu comecei a usar algo assim:

 kill $(pgrep 'python csp_build.py') 

Matar nossos próprios processos iniciados a partir de um PPID comum é bastante frequente, pkill associado à bandeira –P é um vencedor para mim. Usando o exemplo @ ghostdog74:

 # sleep 30 & [1] 68849 # sleep 30 & [2] 68879 # sleep 30 & [3] 68897 # sleep 30 & [4] 68900 # pkill -P $$ [1] Terminated sleep 30 [2] Terminated sleep 30 [3]- Terminated sleep 30 [4]+ Terminated sleep 30 

Você não precisa do interruptor de usuário para ps.

 kill `ps ax | grep 'python csp_build.py' | awk '{print $1}'` 

Em alguns casos, eu gostaria de matar processos simultaneamente desta maneira:

  Sleep ~ dormir 1000 &
 [1] 25410
 Sleep ~ dormir 1000 &
 [2] 25415
 Sleep ~ dormir 1000 &
 [3] 25421
 P ~ pidof sono
 25421 25415 25410
 ➜ ~ matar `pidof sleep`
 [2] - 25415 sono terminado 1000                                                             
 [1] - 25410 sono terminado 1000
 [3] + 25421 sono terminado 1000 

Mas, eu acho que é um pouco inapropriado no seu caso (pode ser que esteja rodando python a, python b, python x … em segundo plano).

Eu uso isso para matar o Firefox quando está sendo script bateu e cpu bashing 🙂 Substitua ‘Firefox’ com o aplicativo que você quer morrer. Eu estou no shell Bash – OS X 10.9.3 Darwin.

kill -Hup $(ps ux | grep Firefox | awk 'NR == 1 {next} {print $2}' | uniq | sort)

Eu uso gkill processname , onde gkill é o seguinte script:

 cnt=`ps aux|grep $1| grep -v "grep" -c` if [ "$cnt" -gt 0 ] then echo "Found $cnt processes - killing them" ps aux|grep $1| grep -v "grep"| awk '{print $2}'| xargs kill else echo "No processes found" fi 

NOTA: NÃO irá matar processos que tenham “grep” nas suas linhas de comando.

O seguinte comando será útil:

kill $(ps -elf | grep | awk {'print $4'})

eg, ps -elf | grep top ps -elf | grep top

  0 T ubuntu 6558 6535 0 80 0 - 4001 signal 11:32 pts/1 00:00:00 top 0 S ubuntu 6562 6535 0 80 0 - 2939 pipe_w 11:33 pts/1 00:00:00 grep --color=auto top 

kill -$(ps -elf | grep top| awk {'print $4'})

  -bash: kill: (6572) - No such process [1]+ Killed top 

Se o processo ainda estiver travado, use a extensão “-9” para o hardkill, da seguinte maneira:

kill -9 $(ps -elf | grep top| awk {'print $4'})

Espero que ajude…!

Encontre e mate todos os processos em uma linha no bash.

 kill -9 $(ps -ef | grep '' | grep -v 'grep' | awk {'print $2'}) 
  • ps -ef | grep '' ps -ef | grep '' – Fornece a lista de detalhes do processo em execução (uname, pid, etc) que corresponde ao padrão. A lista de saída inclui este comando grep que também o pesquisa. Agora, para matar, precisamos ignorar esse processo de comando do grep .
  • ps -ef | grep '' | grep -v 'grep' ps -ef | grep '' | grep -v 'grep' – Adicionando outro grep com -v 'grep' remove o atual processo do grep.
  • Então, usando o awk obtenha o id do processo sozinho.
  • Então mantenha este comando dentro de $(...) e passe para o comando kill , para matar todo o processo.

Você pode usar o comando abaixo para listar o pid do comando. Use top ou use melhor htop para ver todo o processo no linux. Aqui eu quero matar um processo chamado

 ps -ef | grep '/usr/lib/something somelocation/some_process.js' | grep -v grep | awk '{print $2}' 

E verifique o pid. Deve ser adequado. Para matá-los, use o comando kill.

 sudo kill -9 `ps -ef | grep '/usr/lib/something somelocation/some_process.js' | grep -v grep | awk '{print $2}'` 

Por exemplo: – é da lista de processos do htop.

 sudo kill -9 `ps -ef | grep '' | grep -v grep | awk '{print $2}'` 

Isso resolve meus problemas. Esteja sempre preparado para reiniciar o processo se você acidentalmente matar um processo.