Trova e uccidi un processo in una riga usando bash e regex

Ho spesso bisogno di uccidere un processo durante la programmazione.

Il modo in cui lo faccio ora è:

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

Come posso estrarre automaticamente l’id del processo e ucciderlo nella stessa riga?

Come questo:

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

In bash , dovresti essere in grado di fare:

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

I dettagli sul suo funzionamento sono i seguenti:

  • Il ps ti dà la lista di tutti i processi.
  • I filtri grep basati sulla stringa di ricerca, [p] sono un trucco per impedirti di prendere in mano il processo stesso di grep .
  • L’ awk ti dà solo il secondo campo di ogni riga, che è il PID.
  • Il costrutto $(x) significa eseguire x quindi prendere il suo output e metterlo sulla riga di comando. L’output di quella pipeline ps all’interno di quel costrutto sopra è la lista degli ID di processo in modo da finire con un comando come kill 1234 1122 7654 .

Ecco una trascrizione mostrandola in azione:

 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 puoi vedere che termina tutti i dormienti.


Spiegando in modo un po ‘più dettagliato il grep '[p]ython csp_build.py' :

Quando sleep 3600 & segui ps -ef | grep sleep ps -ef | grep sleep , tendi a ottenere due processi con il sleep , il sleep 3600 e il grep sleep (perché entrambi hanno sleep in loro, non è scienza missilistica).

Tuttavia, ps -ef | grep '[s]leep' ps -ef | grep '[s]leep' non creerà un processo con sleep in esso, invece crea grep '[s]leep' ed ecco il difficile: il grep non lo trova perché sta cercando l’espressione regolare ” carattere dalla class di caratteri [s] (che è s ) seguita da leep .

In altre parole, sta cercando il sleep ma il processo di grep '[s]leep' è grep '[s]leep' che non ha sleep in esso.

Quando mi è stato mostrato questo (da qualcuno qui su SO), ho immediatamente iniziato a usarlo perché

  • è un processo in meno rispetto all’aggiunta | grep -v grep | grep -v grep ; e
  • è elegante e subdolo, una combinazione rara 🙂

se hai pkill,

 pkill -f csp_build.py 

Se vuoi solo grep contro il nome del processo (invece della lista completa degli argomenti) allora lascia fuori -f .

Una fodera:

 ps aux | grep -i csp_build | awk '{print $2}' | xargs sudo kill -9 
  • Stampa la colonna 2: awk '{print $2}'
  • sudo è facoltativo
  • Esegui kill -9 5124 , kill -9 5373 ecc. (Kill -15 è più aggraziato ma leggermente più lento)

Bonus:

Ho anche 2 funzioni di scelta rapida definite nel mio .bash_profile (~ / .bash_profile è per osx, devi vedere cosa funziona per la tua macchina * nix).

  1. p parola chiave
    • elenca tutti i processi contenenti parole chiave
    • utilizzo ad es .: p csp_build , p python ecc

codice bash_profile:

 # FIND PROCESS function p(){ ps aux | grep -i $1 | grep -v grep } 
  1. parola chiave ka
    • K ills A ll processi che hanno questa parola chiave
    • uso ad esempio: ka csp_build , ka python ecc
    • livello di uccisione facoltativo, ad esempio: ka csp_build 15 , ka python 9

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

Prova a usare

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

Interpretare il modello del nome del processo come un’espressione regolare estesa.

È ansible utilizzare solo pkill '^python*' per l’eliminazione del processo regex.

Se vuoi vedere cosa ucciderai o troverai prima di uccidere, usa pgrep -l '^python*' dove -l restituisce anche il nome del processo. Se non vuoi usare pkill , usa solo:

pgrep '^python*' | xargs kill

puoi farlo con awk e backtics

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

$ 2 in awk stampa la colonna 2 e i backtics eseguono la dichiarazione stampata.

Ma una soluzione molto più pulita sarebbe che il processo python memorizzasse il proprio ID di processo in / var / run e quindi si può semplicemente leggere quel file e ucciderlo.

Usa pgrep – disponibile su molte piattaforms:

 kill -9 `pgrep -f cps_build` 

pgrep -f restituirà tutti i PID con coincidenza “cps_build”

Il mio compito era di uccidere tutto ciò che corrisponde alla regexp che si trova in una directory specifica (dopo i test sul selenium non tutto si fermava). Questo ha funzionato per me:

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

Per uccidere il processo tramite la parola chiave midori , ad esempio:

kill -SIGTERM $(pgrep -i midori)

Un metodo che utilizza solo awk (e ps ):

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

Usando il test di uguaglianza delle stringhe prevedo di abbinare questo processo stesso.

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

Dai -f per pkill

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

il percorso esatto del file .py è

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

Ho iniziato a usare qualcosa del genere:

 kill $(pgrep 'python csp_build.py') 

Uccidere i nostri processi avviati da un comune PPID è abbastanza frequente, pkill associato alla bandiera –P è un vincitore per me. Usando l’esempio @ 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 

Non hai bisogno dello switch utente per ps.

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

In alcuni casi, mi piacerebbe che i processi di uccisione venissero simulati in questo modo:

  ➜ ~ dormi 1000 e
 [1] 25410
 ➜ ~ dormi 1000 e
 [2] 25415
 ➜ ~ dormi 1000 e
 [3] 25421
 P ~ pidof sonno
 25421 25415 25410
 ➜ ~ uccidere `pidof sleep`
 [2] - 25415 interruzione del sonno 1000                                                             
 [1] - 25410 interruzione del sonno 1000
 [3] + 25421 interruzione del sonno 1000 

Ma, penso che sia un po ‘inappropriato nel tuo caso. (Potrebbe esserci un python in esecuzione a, python b, python x … in background.)

Io uso questo per uccidere Firefox quando è in corso lo script e il bashing della CPU 🙂 Sostituisci “Firefox” con l’app che vuoi morire. Sono sulla shell di Bash – OS X 10.9.3 Darwin.

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

Io uso gkill processname , dove gkill è il seguente 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: NON ucciderà i processi che hanno “grep” nelle loro linee di comando.

Il seguente comando tornerà utile:

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

es., 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 il processo è ancora bloccato, utilizzare l’estensione “-9” su hardkill, come segue:

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

Spero possa aiutare…!

Trova e uccidi tutti i processi in una riga in bash.

 kill -9 $(ps -ef | grep '' | grep -v 'grep' | awk {'print $2'}) 
  • ps -ef | grep '' ps -ef | grep '' – Fornisce l’elenco dei dettagli del processo in esecuzione (uname, pid, ecc.) che corrisponde al modello. L’elenco di output include anche questo comando grep che lo ricerca. Ora per uccidere dobbiamo ignorare questo processo di comando di grep .
  • ps -ef | grep '' | grep -v 'grep' ps -ef | grep '' | grep -v 'grep' – L’aggiunta di un altro grep con -v 'grep' rimuove il processo di grep corrente.
  • Quindi usando awk ottieni l’id di processo da solo.
  • Quindi mantieni questo comando dentro $(...) e passalo a kill command, per uccidere tutto il processo.

È ansible utilizzare il comando seguente per elencare il pid del comando. Usa top o meglio usa htop per visualizzare tutto il processo in linux. Qui voglio uccidere un processo chiamato

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

E verifica il pid. Deve essere corretto. Per ucciderli usa il comando kill.

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

Ad esempio: – è dalla lista dei processi di htop.

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

Questo risolve i miei problemi. Preparati sempre a riavviare il processo se uccidi accidentalmente un processo.