Finden und beenden Sie einen Prozess in einer Zeile mit Bash und Regex

Ich muss oft einen Prozess während der Programmierung beenden.

Ich mache es jetzt so:

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

Wie kann ich die Prozess-ID automatisch extrahieren und in derselben Zeile beenden?

So was:

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

In bashsollten Sie in der Lage sein:

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

Details zu seiner Arbeitsweise sind wie folgt:

• Das psgibt Ihnen die Liste aller Prozesse.
• Die grepFilter, die auf Ihrer Suchzeichenfolge basieren, [p]sind ein Trick, um zu verhindern, dass Sie den eigentlichen grepProzess selbst erfassen.
• Das awkgibt Ihnen nur das zweite Feld jeder Zeile, das die PID ist.
• Das $(x)Konstrukt bedeutet ausführen, xdann seine Ausgabe nehmen und in die Befehlszeile einfügen. Die Ausgabe dieser psPipeline in diesem Konstrukt oben ist die Liste der Prozess-IDs, sodass Sie am Ende einen Befehl wie erhalten kill 1234 1122 7654.

Hier ist ein Transkript, das es in Aktion zeigt:

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

und Sie können sehen, dass es alle Schläfer beendet.

Das grep '[p]ython csp_build.py'Bit etwas ausführlicher erklären :

Wenn Sie sleep 3600 &gefolgt sind ps -ef | grep sleep, neigen Sie dazu, zwei Prozesse sleepdarin zu haben, den sleep 3600und den grep sleep(weil beide sleepin ihnen sind, ist das keine Raketenwissenschaft).

Es ps -ef | grep '[s]leep'wird jedoch kein Prozess sleepdarin erstellt, sondern es wird erstellt, grep '[s]leep'und hier ist das Knifflige: Das grepfindet es nicht, weil es nach dem regulären Ausdruck "jedes Zeichen aus der Zeichenklasse [s](das folgt s) " sucht leep.

Mit anderen Worten, es wird gesucht, sleepaber der Grep-Prozess ist derjenige, grep '[s]leep'der nicht sleepdarin enthalten ist.

Als mir dies gezeigt wurde (von jemandem hier auf SO), fing ich sofort an, es zu benutzen, weil

• Es ist ein Prozess weniger als das Hinzufügen | grep -v grep. und
• es ist elegant und hinterhältig, eine seltene Kombination :-)

wenn du pkill hast,

pkill -f csp_build.py

Wenn Sie nur nach dem Prozessnamen (anstelle der vollständigen Argumentliste) suchen möchten, lassen Sie es aus -f.

Einzeiler:

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

• Spalte 2 ausdrucken: awk '{print $2}'
• sudo es ist optional
• Run kill -9 5124, kill -9 5373etc (kill -15 ist anmutiger , aber etwas langsamer)

Bonus:

Ich habe auch 2 Verknüpfungsfunktionen in meinem .bash_profile definiert (~ / .bash_profile ist für osx, Sie müssen sehen, was für Ihre * nix-Maschine funktioniert).

1. p Schlüsselwort
   • Listen aus allen P rozesse Schlüsselwort enthalten
   • Verwendung zB p csp_build, p pythonusw.

bash_profile code:

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

2. ka Schlüsselwort
   • K Übel A ll Prozesse , die dieses Schlüsselwort
   • Verwendung zB ka csp_build, ka pythonusw.
   • optional Kill Ebene zB: ka csp_build 15,ka python 9

bash_profile code:

# 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

Interpretieren Sie das Prozessnamenmuster als erweiterten regulären Ausdruck.

Versuchen Sie es mit

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

Sie dürfen nur verwenden pkill '^python*' für das Töten von Regex-Prozessen verwenden.

Wenn Sie sehen möchten, was Sie töten oder finden werden, bevor Sie töten, verwenden Sie einfach, pgrep -l '^python*'wobei -l auch den Namen des Prozesses ausgibt. Wenn Sie nicht verwenden möchten pkill, verwenden Sie einfach:

pgrep '^python*' | xargs kill

Verwenden Sie pgrep - verfügbar auf vielen Plattformen:

kill -9 `pgrep -f cps_build`

pgrep -f gibt alle PIDs mit dem Zufall "cps_build" zurück.

Dies gibt nur die PID zurück

pgrep -f 'process_name'

So beenden Sie jeden Prozess in einer Zeile:

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

Wenn Sie den genauen Namen des Prozesses kennen, können Sie auch pidof ausprobieren:

kill -9 $(pidof 'process_name')

Wenn Sie jedoch den genauen Namen des Prozesses nicht kennen, pgrep dies besser.

Wenn mehrere Prozesse mit demselben Namen ausgeführt werden und Sie den ersten beenden möchten, gehen Sie wie folgt vor:

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

Beachten Sie auch, dass Sie die Option -i wie in grep hinzufügen können, wenn Sie sich Sorgen über die Groß- und Kleinschreibung machen. Zum Beispiel:

kill -9 $(pgrep -fi chrome)

Weitere Infos zu Signalen und pgrep unter man 7 signaloder man signalundman pgrep

Sie können es mit awk und backtics tun

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

$ 2 in awk druckt Spalte 2 und das Backtics führt die gedruckte Anweisung aus.

Eine viel sauberere Lösung wäre jedoch, dass der Python-Prozess seine Prozess-ID in / var / run speichert und Sie diese Datei dann einfach lesen und beenden können.

Meine Aufgabe war es, alles zu töten, was mit regulärem Ausdruck übereinstimmt, der sich in einem bestimmten Verzeichnis befindet (nach Selentests wurde nicht alles gestoppt). Das hat bei mir funktioniert:

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

So beenden Sie den Prozess anhand eines Schlüsselworts midori:

kill -SIGTERM $(pgrep -i midori)

Eine Methode, die nur awk(und ps) verwendet:

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

Durch die Verwendung von String-Gleichheitstests verhindere ich, dass dieser Prozess selbst abgeglichen wird.

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

Gib -f zu pkill

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

Der genaue Pfad der .py-Datei ist

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

Ich fing an, so etwas zu benutzen:

kill $(pgrep 'python csp_build.py')

Das Töten unserer eigenen Prozesse, die von einer gemeinsamen PPID aus gestartet wurden, ist ziemlich häufig. Der mit der –PFlagge verbundene Pkill ist für mich ein Gewinner. Beispiel: Verwenden von @ 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

Sie brauchen den Benutzerschalter nicht für ps.

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

In einigen Fällen möchte ich Prozesse gleichzeitig wie folgt beenden:

➜ ~ Schlaf 1000 &
[1] 25410
➜ ~ Schlaf 1000 &
[2] 25415
➜ ~ Schlaf 1000 &
[3] 25421
➜ ~ pidof Schlaf
25421 25415 25410
Kill ~ töte `pidof sleep`
[2] - 25415 beendete den Schlaf 1000                                                             
[1] - 25410 hat den Schlaf 1000 beendet
[3] + 25421 hat den Schlaf 1000 beendet

Aber ich denke, es ist in Ihrem Fall ein wenig unangemessen. (Möglicherweise laufen Python a, Python b, Python x ... im Hintergrund.)

Wenn pkill -f csp_build.pyder Prozess -9nicht abgebrochen wird, können Sie hinzufügen , um ein Kill-Signal zu senden, das nicht ignoriert wird. dhpkill -9 -f csp_build.py

Die Lösung wäre, die Prozesse mit genauem Muster zu filtern, die PID zu analysieren und eine Argumentliste für die Ausführung von Kill-Prozessen zu erstellen:

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

Erklärung aus der Dokumentation:

Das Dienstprogramm ps zeigt eine Kopfzeile an, gefolgt von Zeilen mit Informationen zu allen Prozessen mit Steuerterminals.

-e Zeigt Informationen zu den Prozessen anderer Benutzer an, einschließlich dieser

-f Zeigt die UID, PID, übergeordnete PID, die letzte CPU-Auslastung und den Prozessstart an

Das Dienstprogramm grep durchsucht alle Eingabedateien und wählt die entsprechenden Zeilen aus

-e Muster, --regexp = Muster Geben Sie ein Muster an, das während der Suche nach der Eingabe verwendet wird: Eine Eingabezeile wird ausgewählt, wenn sie mit einem der angegebenen Muster übereinstimmt. Diese Option ist am nützlichsten, wenn mehrere -e-Optionen verwendet werden, um mehrere Muster anzugeben, oder wenn ein Muster mit einem Bindestrich (`- ') beginnt.

xargs - Argumentliste (n) erstellen und Dienstprogramm ausführen

töten - einen Prozess beenden oder signalisieren

Signal Nummer 9 - KILL (nicht fangbarer, nicht ignorierbarer Kill)

Beispiel :

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

Ich benutze dies, um Firefox zu töten, wenn das Skript zugeschlagen wird und die CPU aufgeschlagen wird :) Ersetzen Sie 'Firefox' durch die App, die Sie sterben möchten. Ich bin auf der Bash-Shell - OS X 10.9.3 Darwin.

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

Ich benutze gkill processname, wobei gkill das folgende Skript ist:

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

HINWEIS: Prozesse, deren Befehlszeilen "grep" enthalten, werden NICHT beendet.

Der folgende Befehl ist praktisch:

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

z.B., 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

Wenn der Prozess immer noch nicht funktioniert, verwenden Sie die Erweiterung "-9", um Hardkill wie folgt auszuführen:

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

Ich hoffe, das hilft...!

Finde und töte alle Prozesse in einer Zeile in Bash.

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

• ps -ef | grep '<exe_name>'- Gibt die Liste der laufenden Prozessdetails (uname, pid usw.) an, die dem Muster entsprechen. Die Ausgabeliste enthält diesen grepBefehl auch, der ihn durchsucht. Zum Töten müssen wir diesen grepBefehlsprozess ignorieren .
• ps -ef | grep '<exec_name>' | grep -v 'grep'- Durch Hinzufügen eines weiteren Grep mit -v 'grep'wird der aktuelle Grep-Prozess entfernt.
• Verwenden awkSie dann nur die Prozess-ID.
• Behalten Sie dann diesen Befehl im Inneren $(...)und übergeben Sie ihn an den killBefehl, um alle Prozesse abzubrechen.

Sie können den folgenden Befehl verwenden, um die PID des Befehls aufzulisten. Verwenden Sie top oder besser htop, um alle Prozesse unter Linux anzuzeigen. Hier möchte ich einen Prozess namens beenden

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

Und überprüfen Sie die PID. Es muss richtig sein. Um sie zu töten, benutze den Befehl kill.

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

ZB: - stammt aus der htop-Prozessliste.

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

Dies löst meine Probleme. Seien Sie immer bereit, den Prozess neu zu starten, wenn Sie versehentlich einen Prozess beenden.