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

Spesso devo interrompere 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 <regex that returns the pid>

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 grepfiltri che in base alla stringa di ricerca,[p] sono un trucco per impedirti di raccogliere il grepprocesso stesso.
• Il awk giusto ti dà il secondo campo di ogni riga, che è il PID.
• Il $(x)costrutto significa eseguire xquindi prendere il suo output e inserirlo nella riga di comando. L'output di quella pspipeline all'interno di quel costrutto sopra è la lista degli ID di processo in modo da finire con un comando similekill 1234 1122 7654 .

Ecco una trascrizione che lo mostra 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 vederlo terminare tutti i dormienti.

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

Quando lo fai sleep 3600 &seguito ps -ef | grep sleep, tendi ad avere due processi con sleepin esso, il sleep 3600e il grep sleep(perché entrambi hannosleep in loro, questa non è scienza missilistica).

Tuttavia, ps -ef | grep '[s]leep'non creerà un processo con sleepal suo interno, crea invece grep '[s]leep'ed ecco il trucco: grepnon lo trova perché sta cercando l'espressione regolare "qualsiasi personaggio della classe di caratteri [s](che è s) seguito daleep .

In altre parole, sta cercando sleepma il processo grep è grep '[s]leep'che non hasleep 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 ; e
• è elegante e subdolo, una combinazione rara :-)

se hai pkill,

pkill -f csp_build.py

Se vuoi solo fare grep contro il nome del processo (invece che l'elenco completo degli argomenti), lascia perdere -f.

Una fodera:

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

• Stampa colonna 2: awk '{print $2}'
• sudo è facoltativo
• Esegui kill -9 5124, kill -9 5373ecc. (Uccidere -15 è più grazioso ma leggermente più lento)

Bonus:

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

1. parola chiave p
   • elenca tutto P rocesses contenenti parole chiave
   • utilizzo ad es .: p csp_build, p pythonecc

codice bash_profile:

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

2. parola chiave ka
   • K ills A processi ll che hanno questa parola chiave
   • utilizzo ad es .: ka csp_build,ka pythonecc
   • livello di uccisione opzionale ad es .: 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"
}

killall -r regexp

-r, --regexp

Interpretazione del modello del nome del processo come espressione regolare estesa.

Prova a usare

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

Puoi usare solo pkill '^python*'per uccidere il processo regex.

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

pgrep '^python*' | xargs kill

Usa pgrep - disponibile su molte piattaforme:

kill -9 `pgrep -f cps_build`

pgrep -f restituirà tutti i PID con coincidenza "cps_build"

Questo restituirà solo il pid

pgrep -f 'process_name'

Quindi, per terminare qualsiasi processo in una riga:

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

oppure, se conosci il nome esatto del processo, puoi provare anche pidof:

kill -9 $(pidof 'process_name')

Ma, se non si conosce il nome esatto del processo, pgrepsarebbe meglio.

Se sono in esecuzione più processi con lo stesso nome e si desidera terminare il primo:

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

Inoltre, se sei preoccupato per la distinzione tra maiuscole e minuscole, puoi aggiungere l'opzione -i proprio come in grep. Per esempio:

kill -9 $(pgrep -fi chrome)

Maggiori informazioni su segnali e pgrep su man 7 signalo man signaleman pgrep

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 il backtics esegue l'istruzione stampata.

Ma una soluzione molto più pulita sarebbe che il processo python memorizzi il suo ID di processo in / var / run e quindi puoi semplicemente leggere quel file e ucciderlo.

Il mio compito era quello di uccidere tutto ciò che corrispondeva a regexp che si trova in una directory specifica (dopo che i test del selenio non si sono fermati). 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 terminare il processo per 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 impedisco di abbinare questo processo stesso.

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

Dare -f a 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 partendo da un PPID comune è abbastanza frequente, pkill associato alla –Pbandiera è un vincitore per me. Usando l'esempio di @ 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 è necessario il cambio utente per ps.

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

In alcuni casi, mi piacerebbe uccidere i processi contemporaneamente in questo modo:

➜ ~ dormire 1000 e
[1] 25410
➜ ~ dormire 1000 e
[2] 25415
➜ ~ dormire 1000 e
[3] 25421
~ Pidof sleep
25421 25415 25410
Kill ~ uccidi `pidof sleep`
[2] - 25415 sonno terminato 1000                                                             
[1] - 25410 sleep terminato 1000
[3] + 25421 sonno terminato 1000

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

Se pkill -f csp_build.pyil processo non viene -9interrotto, è possibile aggiungerlo per inviare un segnale di errore che non verrà ignorato. vale a direpkill -9 -f csp_build.py

La soluzione consisterebbe nel filtrare i processi con un modello esatto, analizzare il pid e costruire un elenco di argomenti per l'esecuzione dei processi di interruzione:

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

Spiegazione dalla documentazione:

L' utilità ps visualizza una riga di intestazione, seguita da righe contenenti informazioni su tutti i processi che hanno terminali di controllo.

-e Visualizza informazioni sui processi di altri utenti, inclusi quelli

-f Visualizza uid, pid, pid parent, utilizzo recente della CPU, avvio del processo

L' utilità grep cerca qualsiasi dato file di input, selezionando le righe

-e pattern, --regexp = pattern Specifica un modello usato durante la ricerca dell'input: viene selezionata una linea di input se corrisponde a uno dei pattern specificati. Questa opzione è particolarmente utile quando vengono utilizzate più opzioni -e per specificare più motivi o quando un motivo inizia con un trattino (`- ').

xargs - costruisce una lista di argomenti ed esegue l'utilità

kill - termina o segnala un processo

segnale numero 9 - KILL (uccisione non catchable, non ignorabile)

Esempio :

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

Lo uso per uccidere Firefox quando viene sbattuto lo script e cpu bashing :) Sostituisci "Firefox" con l'app che vuoi morire. Sono sulla shell Bash - OS X 10.9.3 Darwin.

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

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 sarà utile:

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

per esempio., 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" per hardkill, come segue:

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

Spero che aiuti...!

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

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

• ps -ef | grep '<exe_name>'- Fornisce l'elenco dei dettagli del processo in esecuzione (uname, pid, ecc.) Che corrisponde al modello. L'elenco di output include anche questo grepcomando che lo cerca. Ora per uccidere dobbiamo ignorare questo grepprocesso di comando.
• ps -ef | grep '<exec_name>' | grep -v 'grep'- L'aggiunta di un altro grep con -v 'grep'rimuove l'attuale processo grep.
• Quindi utilizzando awkget id processo da solo.
• Quindi tieni questo comando dentro $(...)e passalo al killcomando, per terminare tutto il processo.

È possibile utilizzare il comando seguente per elencare il pid del comando. Usa top o meglio usa htop per visualizzare tutti i processi 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: - proviene dall'elenco dei processi htop.

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

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