Rechercher et tuer un processus sur une seule 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 sur la même ligne?

Comme ça:

[~]$ ps aux | grep 'python csp_build.py' | kill <regex that returns the pid>

Dans bash, vous devriez pouvoir faire:

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

Les détails de son fonctionnement sont les suivants:

• Le psvous donne la liste de tous les processus.
• Les grepfiltres basés sur votre chaîne de recherche [p]sont une astuce pour vous empêcher de récupérer le grepprocessus lui-même.
• Le awkjuste vous donne le deuxième champ de chaque ligne, qui est le PID.
• La $(x)construction signifie exécuter xpuis prendre sa sortie et la mettre sur la ligne de commande. La sortie de ce pspipeline à l'intérieur de cette construction ci-dessus est la liste des ID de processus, vous vous retrouvez donc 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.

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

Lorsque vous ne sleep 3600 &suiviez par ps -ef | grep sleep, vous avez tendance à deux processus avec sleepen elle, la sleep 3600et grep sleep(parce qu'ils ont tous les deux sleepen eux, ce n'est pas sorcier).

Cependant, ps -ef | grep '[s]leep'ne créera pas de processus avec sleep, il crée à la place grep '[s]leep'et voici le bit délicat: le grepne le trouve pas car il recherche l'expression régulière "n'importe quel caractère de la classe de caractères [s](qui est s) suivi par leep.

En d'autres termes, il est à la recherche, sleepmais le processus grep est celui grep '[s]leep'qui ne s'y trouve pas sleep.

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

• c'est un processus de moins que l'ajout | grep -v grep; et
• c'est élégant et sournois, une combinaison rare :-)

si vous avez pkill,

pkill -f csp_build.py

Si vous souhaitez uniquement effectuer une grep contre le nom du processus (au lieu de la liste complète des arguments), laissez-la désactivée -f.

Bon mot:

ps aux | grep -i csp_build | awk '{print $2}' | xargs sudo kill -9

• Imprimez la colonne 2: awk '{print $2}'
• sudo est facultatif
• Run kill -9 5124, kill -9 5373etc (kill -15 est plus gracieux mais légèrement plus lent)

Prime:

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

1. mot-clé p
   • listes sur tous les P rocessus contenant mot - clé
   • utilisation par exemple: p csp_build, p pythonetc.

code bash_profile:

# FIND PROCESS
function p(){
        ps aux | grep -i $1 | grep -v grep
}

2. mot clé ka
   • K ills A ll processus qui ont ce mot-clé
   • utilisation par exemple: ka csp_build, ka pythonetc.
   • option kill niveau 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"
}

killall -r regexp

-r, --regexp

Interpréter le modèle de nom de processus comme une expression régulière étendue.

Essayez d'utiliser

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

Vous ne pouvez utiliser que pkill '^python*' pour tuer des processus d'expression régulière.

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

pgrep '^python*' | xargs kill

Utilisez pgrep - disponible sur de nombreuses plateformes:

kill -9 `pgrep -f cps_build`

pgrep -f renverra tous les PID avec une coïncidence "cps_build"

Cela renverra le pid uniquement

pgrep -f 'process_name'

Donc, pour tuer n'importe quel processus en une seule ligne:

kill -9 $(pgrep -f 'process_name')

ou, si vous connaissez le nom exact du processus, vous pouvez également essayer pidof:

kill -9 $(pidof 'process_name')

Mais, si vous ne connaissez pas le nom exact du processus, ce pgrepserait mieux.

S'il y a plusieurs processus en cours d'exécution avec le même nom et que vous voulez tuer le premier, alors:

kill -9 $(pgrep -f 'process_name' | head -1)

Notez également que, si vous vous inquiétez de la sensibilité à la casse, vous pouvez ajouter l'option -i comme dans grep. Par exemple:

kill -9 $(pgrep -fi chrome)

Plus d'informations sur les signaux et pgrep sur man 7 signalou man signaletman pgrep

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 les backtics exécutent l'instruction qui est imprimée.

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

Ma tâche était de tuer tout ce qui correspond à l'expression rationnelle qui est placé dans un répertoire spécifique (après les tests au sélénium, 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 le processus par mot midori- clé , 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

Donner -f à 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 démarrés à partir d'un PPID commun est assez fréquent, pkill associé au –Pdrapeau est un gagnant pour moi. En utilisant l'exemple de @ 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, j'aimerais tuer des processus simultanément comme ceci:

➜ ~ dormir 1000 &
[1] 25410
➜ ~ dormir 1000 &
[2] 25415
➜ ~ dormir 1000 &
[3] 25421
➜ ~ pidof sommeil
25421 25415 25410
➜ ~ tuer `pidof sleep`
[2] - 25415 a mis fin au sommeil 1000                                                             
[1] - 25410 a mis fin au sommeil 1000
[3] + 25421 a mis fin au sommeil 1000

Mais je pense que c'est un peu inapproprié dans votre cas (il se peut qu'il y ait python a, python b, python x ... en arrière-plan).

Si pkill -f csp_build.pyne tue pas le processus, vous pouvez ajouter -9pour envoyer un signal de mise à mort qui ne sera pas ignoré. c'est à direpkill -9 -f csp_build.py

La solution serait de filtrer les processus avec le modèle exact, d'analyser le pid et de construire une liste d'arguments pour exécuter les processus de suppression:

ps -ef  | grep -e <serviceNameA> -e <serviceNameB> -e <serviceNameC> |
awk '{print $2}' | xargs sudo kill -9

Explication de la documentation:

L' utilitaire ps affiche une ligne d'en-tête, suivie de lignes contenant des informations sur tous vos processus qui ont des terminaux de contrôle.

-e Afficher des informations sur les processus des autres utilisateurs, y compris ceux

-f Affiche l'uid, le pid, le pid parent, l'utilisation récente du processeur, le démarrage du processus

L' utilitaire grep recherche les fichiers d'entrée donnés, en sélectionnant les lignes

-e motif, --regexp = motif Spécifiez un motif utilisé lors de la recherche de l'entrée: une ligne d'entrée est sélectionnée si elle correspond à l'un des motifs spécifiés. Cette option est particulièrement utile lorsque plusieurs options -e sont utilisées pour spécifier plusieurs modèles, ou lorsqu'un modèle commence par un tiret (`- ').

xargs - construire des listes d'arguments et exécuter l'utilitaire

kill - terminer ou signaler un processus

signal numéro 9 - KILL (kill non capturable, non ignorable)

Exemple :

ps -ef  | grep -e node -e loggerUploadService.sh - -e applicationService.js |
awk '{print $2}' | xargs sudo kill -9

J'utilise cela pour tuer Firefox quand il est critiqué et basé sur le processeur :) Remplacez 'Firefox' par 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

REMARQUE: cela ne tuera PAS les processus qui ont "grep" dans leurs lignes de commande.

La commande suivante sera utile:

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

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

Trouvez et tuez tous les processus en une seule ligne dans bash.

kill -9 $(ps -ef | grep '<exe_name>' | grep -v 'grep' | awk {'print $2'})

• ps -ef | grep '<exe_name>'- Donne la liste des détails du processus en cours (uname, pid, etc.) qui correspondent au modèle. La liste de sortie inclut grepégalement cette commande qui la recherche. Maintenant, pour tuer, nous devons ignorer celagrep processus de commande.
• ps -ef | grep '<exec_name>' | grep -v 'grep'- L'ajout d'un autre grep avec -v 'grep'supprime le processus grep actuel.
• Ensuite, utilisez awkuniquement l'ID de processus.
• Ensuite, gardez cette commande à l'intérieur $(...)et passez-la à la killcommande, 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 afficher 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. Il doit être approprié. 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 des processus htop.

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

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