Trouver et tuer un processus dans une ligne en utilisant bash et regex

J’ai souvent besoin de tuer un processus pendant la programmation.

La façon dont je le fais maintenant est la suivante:

[~]$ 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 

Comment puis-je extraire l’ID de processus automatiquement et le tuer dans la même ligne?

Comme ça:

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

En bash , vous devriez être capable de faire:

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

Les détails sur son fonctionnement sont les suivants:

  • Le ps vous donne la liste de tous les processus.
  • Le grep filtre en fonction de votre chaîne de recherche, [p] est une astuce pour vous empêcher de récupérer le processus grep proprement dit.
  • L’ awk vous donne juste le deuxième champ de chaque ligne, qui est le PID.
  • La construction $(x) signifie exécuter x puis prendre sa sortie et la placer sur la ligne de commande. La sortie de ce pipeline ps dans cette construction ci-dessus est la liste des identifiants de processus afin que vous vous retrouviez avec une commande comme kill 1234 1122 7654 .

Voici une transcription le montrant en action:

 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 

et vous pouvez le voir terminer tous les dormeurs.


Expliquer un peu plus en détail le grep '[p]ython csp_build.py' :

Lorsque vous sleep 3600 & suivi de ps -ef | grep sleep ps -ef | grep sleep , vous avez tendance à avoir deux processus avec le sleep , le sleep 3600 et le grep sleep (parce qu’ils ont tous les deux un sleep , ce n’est pas sorcier).

Cependant, ps -ef | grep '[s]leep' ps -ef | grep '[s]leep' ne créera pas de processus avec le sleep , il crée à la place grep '[s]leep' et voici le bit le plus délicat: le grep ne le trouve pas car il cherche l’expression régulière “any caractère de la classe de caractère ( s ) suivi de leep .

En d’autres termes, il recherche le sleep mais le processus de grep est grep '[s]leep' qui ne contient pas de sleep .

Quand on m’a montré ceci (par quelqu’un ici sur SO), j’ai immédiatement commencé à l’utiliser parce que

  • c’est un processus de moins que d’append | grep -v grep | grep -v grep ; et
  • c’est élégant et sournois, une combinaison rare 🙂

si tu as pkill,

 pkill -f csp_build.py 

Si vous ne voulez que grep contre le nom du processus (au lieu de la liste complète des arguments), alors désactivez -f .

Bon mot:

 ps aux | grep -i csp_build | awk '{print $2}' | xargs sudo kill -9 
  • Imprimer la colonne 2: awk '{print $2}'
  • sudo est optionnel
  • Lancer kill -9 5124 , kill -9 5373 etc (kill -15 est plus gracieux mais légèrement plus lent)

Prime:

J’ai aussi 2 fonctions de raccourci définies dans mon fichier .bash_profile (~ / .bash_profile est pour osx, vous devez voir ce qui fonctionne pour votre machine * nix).

  1. p mot clé
    • liste tous les processus contenant un mot clé
    • utilisation par exemple: p csp_build , p python etc

Code bash_profile:

 # FIND PROCESS function p(){ ps aux | grep -i $1 | grep -v grep } 
  1. mot clé ka
    • K ills Tous les processus qui ont ce mot-clé
    • utilisation par exemple: ka csp_build , ka python etc
    • niveau de ka csp_build 15 facultatif, par exemple: ka csp_build 15 , ka python 9

code 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" } 

Essayez d’utiliser

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

Interpréter le modèle de nom de processus en tant qu’expression régulière étendue.

Vous ne pouvez utiliser que pkill '^python*' pour le traitement des regex.

Si vous voulez voir ce que vous allez tuer ou trouver avant de tuer, utilisez simplement pgrep -l '^python*' où -l affiche aussi le nom du processus. Si vous ne voulez pas utiliser pkill , utilisez uniquement:

pgrep '^python*' | xargs kill

vous pouvez le faire avec awk et backtics

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

$ 2 dans awk imprime la colonne 2 et le backtics exécute l’instruction imprimée.

Mais une solution beaucoup plus propre serait que le processus python stocke son identifiant de processus dans / var / run et que vous puissiez simplement lire ce fichier et le tuer.

Utilisez pgrep – disponible sur de nombreuses plates-formes:

 kill -9 `pgrep -f cps_build` 

pgrep -f renverra tous les PID avec coïncidence “cps_build”

Ma tâche était de tuer tout ce qui correspond à l’expression rationnelle qui est placée dans un répertoire spécifique (après les tests de selenium, tout ne s’est pas arrêté). Cela a fonctionné pour moi:

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

Pour tuer un processus par mot-clé midori , par exemple:

kill -SIGTERM $(pgrep -i midori)

Une méthode utilisant uniquement awk (et ps ):

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

En utilisant le test d’égalité de chaîne, j’empêche de faire correspondre ce processus lui-même.

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

Donne-à pkill

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

le chemin exact du fichier .py est

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

J’ai commencé à utiliser quelque chose comme ça:

 kill $(pgrep 'python csp_build.py') 

Tuer nos propres processus à partir d’un PPID commun est assez fréquent, pkill associé à l’indicateur –P est un gagnant pour moi. En utilisant l’exemple @ 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 

Vous n’avez pas besoin du commutateur utilisateur pour ps.

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

Dans certains cas, je voudrais tuer les processus de la même manière:

  Sleep ~ dormir 1000 &
 [1] 25410
 Sleep ~ dormir 1000 &
 [2] 25415
 Sleep ~ dormir 1000 &
 [3] 25421
 Sleep ~ pid de sumil
 25421 25415 25410
 Kill ~ tuer `pidof sleep`
 [2] - 25415 sumil terminé 1000                                                             
 [1] - 25410 sumil terminé 1000
 [3] + 25421 sumil terminé 1000 

Mais je pense que c’est un peu inapproprié dans votre cas (il peut y avoir en cours d’exécution python a, python b, python x …).

Je l’utilise pour tuer Firefox quand il est critiqué par le script et cpu bashing 🙂 Remplacez ‘Firefox’ avec l’application que vous voulez mourir. Je suis sur le shell Bash – OS X 10.9.3 Darwin.

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

J’utilise gkill processname , où gkill est le script suivant:

 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 

NOTE: il ne supprimera PAS les processus qui ont “grep” dans leurs lignes de commande.

La commande suivante vous sera utile:

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

par exemple, 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 

Si le processus est toujours bloqué, utilisez l’extension “-9” pour hardkill, comme suit:

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

J’espère que cela pourra aider…!

Trouver et tuer tous les processus dans une ligne dans bash.

 kill -9 $(ps -ef | grep '' | grep -v 'grep' | awk {'print $2'}) 
  • ps -ef | grep '' ps -ef | grep '' – Donne la liste des détails du processus en cours d’exécution (uname, pid, etc.) correspondant au modèle. La liste de sortie inclut cette commande grep également qui la recherche. Maintenant, pour tuer, nous devons ignorer ce processus de commande grep .
  • ps -ef | grep '' | grep -v 'grep' ps -ef | grep '' | grep -v 'grep' – L’ajout d’un autre grep avec -v 'grep' supprime le processus grep actuel.
  • Ensuite, utilisez awk obtenir l’identifiant du processus seul.
  • Ensuite, gardez cette commande dans $(...) et passez-la à kill commande, pour tuer tous les processus.

Vous pouvez utiliser la commande ci-dessous pour répertorier le pid de la commande. Utilisez top ou mieux utilisez htop pour voir tous les processus sous Linux. Ici, je veux tuer un processus nommé

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

Et vérifiez le pid. Cela doit être correct. Pour les tuer, utilisez la commande kill.

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

Par exemple: – provient de la liste de processus htop.

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

Cela résout mes problèmes. Soyez toujours prêt à redémarrer le processus si vous détruisez accidentellement un processus.