Zoek en stop een proces in één regel met bash en regex

June 14, 2022

Ik moet vaak een proces beëindigen tijdens het programmeren.

De manier waarop ik het nu doe is:

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

Hoe kan ik de proces-ID automatisch extraheren en in dezelfde regel doden?

Zoals dit:

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

Antwoord 1, autoriteit 100%

In bashzou je het volgende moeten kunnen doen:

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

Details over de werking zijn als volgt:

De psgeeft je de lijst met alle processen.
De grep-filters die op basis van uw zoekreeks, [p], een truc zijn om te voorkomen dat u het daadwerkelijke grep-proces zelf oppikt .
De awkgeeft je alleen het tweede veld van elke regel, de PID.
De constructie $(x)betekent om xuit te voeren en vervolgens de uitvoer te nemen en deze op de opdrachtregel te plaatsen. De uitvoer van die ps-pijplijn binnen die constructie hierboven is de lijst met proces-ID’s, zodat je eindigt met een opdracht als kill 1234 1122 7654.

Hier is een transcript dat het in actie laat zien:

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

en je kunt zien dat het alle slapers beëindigt.

De grep '[p]ython csp_build.py'beetje meer in detail uitleggen:

Als je sleep 3600 &doet, gevolgd door ps -ef | grep sleep, je krijgt meestal tweeprocessen met sleeperin, de sleep 3600en de grep sleep(omdat ze allebei sleepin zich hebben, is dat geen rocket science).

Echter, ps -ef | grep '[s]leep'maakt geen proces met sleeperin, maar creëert in plaats daarvan grep '[s]leep'en hier is het lastige bit: de grepvindt het niet omdat het zoekt naar de reguliere expressie “elk teken uit de tekenklasse [s](dat is s) gevolgd door leep.

Met andere woorden, het zoekt naar sleepmaar het grep-proces is grep '[s]leep'dat geen sleepheeft erin.

Toen ik dit te zien kreeg (door iemand hier op SO), begon ik het meteen te gebruiken omdat

het is één proces minder dan het toevoegen van | grep -v grep; en
het is elegant enstiekem, een zeldzame combinatie 🙂

Antwoord 2, autoriteit 11%

als je pkill hebt,

pkill -f csp_build.py

Als je alleen grep wilt tegen de procesnaam (in plaats van de volledige lijst met argumenten), laat dan -fweg.

Antwoord 3, autoriteit 7%

Eén voering:

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

Kolom 2 afdrukken: awk '{print $2}'
sudois optioneel
Voer kill -9 5124, kill -9 5373enz. uit (kill -15 is eleganter maar iets langzamer)

Bonus:

Ik heb ook 2 snelkoppelingsfuncties gedefinieerd in mijn .bash_profile
(~/.bash_profile is voor osx, je moet kijken wat werkt voor je *nix-machine).

pzoekwoord
- geeft alle Processes weer die trefwoord
- gebruik bijv.: p csp_build, p pythonetc

bash_profile-code:

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

kazoekwoord
- Kills Eenalle processen die dit trefwoord hebben
- gebruik bijv.: ka csp_build, ka pythonetc
- optioneel kill-niveau, bijvoorbeeld: 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"
}

Antwoord 4

killall -r regexp
-r, --regexp

Interpreteer procesnaampatroon als een uitgebreide reguliere expressie.

Antwoord 5

Probeer

. te gebruiken

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

Antwoord 6

Hiermee wordt alleen de pid geretourneerd

pgrep -f 'process_name'

Dus om elk proces in één regel te stoppen:

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

of, als je de exacte naam van het proces weet, kun je ook pidof proberen:

kill -9 $(pidof 'process_name')

Maar als u de exacte naam van het proces niet weet, zou pgrepbeter zijn.

Als er meerdere processen lopen met dezelfde naam, en je wilt de eerste doden, dan:

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

Ook om op te merken dat, als u zich zorgen maakt over hoofdlettergevoeligheid, u de -i-optie kunt toevoegen, net als in grep. Bijvoorbeeld:

kill -9 $(pgrep -fi chrome)

Meer info over signalen en pgrep bij man 7 signalof man signalen man pgrep

Antwoord 7

Je mag alleen pkill '^python*'gebruiken voor het doden van regex-processen.

Als je wilt zien wat je gaat doden of vinden voordat je gaat doden, gebruik dan gewoon pgrep -l '^python*'waarbij -l ook de naam van het proces uitvoert. Als u niet wilt gebruiken
pkill, gebruik gewoon:

pgrep '^python*' | xargs kill

Antwoord 8

Gebruik pgrep – beschikbaar op veel platforms:

kill -9 `pgrep -f cps_build`

pgrep -f retourneert alle PID’s met toeval “cps_build”

Antwoord 9

In sommige gevallen wil ik processen tegelijkertijd op deze manier uitschakelen:

➜ ~ slaap 1000 &
[1] 25410
➜ ~ slaap 1000 &
[2] 25415
➜ ~ slaap 1000 &
[3] 25421
➜ ~ pidof slaap
25421 25415 25410
➜ ~ dood `pidof sleep`
[2] - 25415 beëindigde slaapstand 1000
[1] - 25410 slaapstand beëindigd 1000
[3] + 25421 slaapstand 1000 beëindigd

Maar ik denk dat het een beetje ongepast is in jouw geval. (Misschien draaien er python a, python b, python x… op de achtergrond.)

Antwoord 10

Als pkill -f csp_build.pyhet proces niet doodt, kun je -9toevoegen om een kill-signaal te verzenden dat niet zal worden genegeerd. bijv. pkill -9 -f csp_build.py

Antwoord 11

Veel goede antwoorden hier – ik heb het antwoord gebruikt dat door de OP is geaccepteerd. Gewoon een kleine waarschuwing toevoegen over pkillen pgrep. Zoals je zou kunnen zien op hun man-pagina’s, hebben sommige besturingssystemen een 15 -karakterlimiet voor de procesnaam. De optie -flost dat op mijn besturingssysteem op, maar ik had problemen totdat ik die optie vond!

Antwoord 12

Ik gebruik dit om Firefox te doden wanneer het script wordt dichtgeslagen en cpu bashen 🙂
Vervang ‘Firefox’ door de app die je dood wilt. Ik ben op de Bash-shell – OS X 10.9.3 Darwin.

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

Antwoord 13

Ik gebruik gkill processname, waarbij gkill het volgende script is:

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

OPMERKING: het zal GEEN processen doden die “grep” in hun commandoregels hebben.

Antwoord 14

Gebruik `-C`vlag van `ps`commando

-C cmdlist
     Select by command name.  This selects the processes whose
     executable name is given in cmdlist.

Eerste geval, eenvoudig commando

Dus als je je script uitvoert met standaard shebangen ze bij zijn naam noemt:

/path/to/csp_build.py

Misschien vind je ze met

ps -C csp_build.py

Dus

kill $(ps -C csp_build.py ho pid)

misschien genoeg.

2e hoofdletters, zoek naar cmd

Iets sterker, maar nog steeds een stuk sneller dan de meeste andere antwoorden op deze SO-vraag…

Als je niet weet hoe dit wordt gerund, of als je ze uitvoert door

python csp_build.py
python3 csp_build.py
python /path/to/csp_build.py

Je kunt ze vinden door het volgende uit te voeren:

ps -C python,python3,csp_build.py who pid,cmd | grep csp_build.py

Gebruik vervolgens sed:

kill $(ps -C python,python3,csp_build.py who pid,cmd |
    sed -ne '/csp_build.py/s/^ *\([0-9]\+\) .*$/\1/p')

Antwoord 15

Gebaseerd op https://stackoverflow.com/a/3510879/15603477antwoord. Kleine optimalisatie.

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

Door tr -s ' 'te gebruiken om meerdere witruimten (indien aanwezig) tot 1 witruimte te persen.

Als u Operation not permittedtegenkomt, volg dan dit>> https://unix. stackexchange.com/questions/89316/how-to-kill-a-process-that-says-operation-not-permitted-when-attempted

Antwoord 16

Het volgende commando is handig:

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

bijv.,
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

Als het proces nog steeds vastloopt, gebruik dan de extensie “-9” voor hardkill, als volgt:

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

Hopelijk helpt dat…!

Antwoord 17

Zoek en stop alle processen in één regel in bash.

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

ps -ef | grep '<exe_name>'– Geeft de lijst met lopende procesdetails (uname, pid, etc ) die overeenkomen met het patroon. De uitvoerlijst bevat ook deze grep-opdracht die ernaar zoekt. Voor het doden moeten we dit grep-opdrachtproces negeren.
ps -ef | grep '<exec_name>' | grep -v 'grep'– Door nog een grep toe te voegen met -v 'grep'wordt het huidige grep-proces verwijderd.
Gebruik vervolgens awkom alleen de proces-ID te krijgen.
Bewaar dit commando dan binnen $(...)en geef het door aan het commando killom alle processen te beëindigen.

Antwoord 18

U kunt het onderstaande commando gebruiken om de pid van het commando weer te geven. Gebruik top of beter gebruik htop om alle processen in linux te bekijken. Hier wil ik een proces doden met de naam

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

En verifieer de pid. Het moet correct zijn. Om ze te doden, gebruik je het kill-commando.

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

Bijvoorbeeld:- komt uit de htop-proceslijst.

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

Dit lost mijn problemen op. Wees altijd voorbereid om het proces opnieuw te starten als u per ongeluk een proces beëindigt.

Previous articleErvaring met het gebruik van de Boost.Log-logboekregistratiebibliotheek?

Next articleWaarom is het sleutelwoord ‘this’ vereist om een extensiemethode aan te roepen vanuit de extended class