Jeśli masz pkill,

pkill -f csp_build.py

Jeśli chcesz używać grep tylko przeciwko nazwie procesu (zamiast pełnej listy argumentów), zostaw -f.

Jedna linijka:

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

• Wydrukuj kolumnę 2: awk '{print $2}'
• sudo jest opcjonalne
• Run kill -9 5124, kill -9 5373 w tym samym czasie kill -15 jest bardziej wdzięczny, ale nieco wolniejszy.]}

Bonus:

Mam również 2 funkcje skrótu zdefiniowane w moim .bash_profile (~/.bash_profile jest dla osx, musisz zobaczyć, co działa na twoim komputerze * nix).

1. p słowo kluczowe
   • wypisuje wszystkie P rokosze zawierające słowo kluczowe
   • użycie np.: p csp_build , p python etc

bash_profile code:

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

1. ka słowo kluczowe
   • K ills A ll procesy, które mają to słowo kluczowe
   • użycie np.: ka csp_build , ka python etc
   • opcjonalny poziom zabijania np.: 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

Interpretuje wzorzec nazwy procesu jako rozszerzone Wyrażenie regularne.

Spróbuj użyć

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

Możesz używać tylko pkill '^python*' do zabijania procesów regex.

Jeśli chcesz zobaczyć, co chcesz zabić lub znaleźć przed zabiciem, użyj pgrep -l '^python*' Gdzie-l wyświetla również nazwę procesu. Jeśli nie chcesz używać pkill, Użyj tylko:

pgrep '^python*' | xargs kill

Zwróci tylko pid

pgrep -f 'process_name'

Więc aby zabić dowolny proces w jednej linii:

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

Lub, jeśli znasz dokładną nazwę procesu, możesz również spróbować pidof:

kill -9 $(pidof 'process_name')

Ale jeśli nie znasz dokładnej nazwy procesu, pgrep byłoby lepiej.

Jeśli istnieje wiele procesów o tej samej nazwie i chcesz zabić pierwszy, to:

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

Należy również zauważyć, że jeśli martwisz się o wrażliwość na wielkość liter, możesz dodać opcję-i tak jak w grep. Na przykład:

kill -9 $(pgrep -fi chrome)

Więcej informacji o sygnałach i pgrep na man 7 signal lub man signal i man pgrep

Użyj pgrep-dostępnego na wielu platformach:

kill -9 `pgrep -f cps_build`

Pgrep-f zwróci wszystkie PID ze zbiegiem okoliczności "cps_build"

Możesz to zrobić z awk i backtics

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

$2 w awk wyświetla kolumnę 2, a backtics uruchamia instrukcję, która została wydrukowana.

Ale o wiele czystszym rozwiązaniem byłoby, gdyby proces Pythona przechowywał swój identyfikator procesu w /var / run, a następnie można go po prostu odczytać i zabić.

Moim zadaniem było zabicie wszystkiego pasującego do wyrażenia regularnego, które jest umieszczone w konkretnym katalogu (po testach selenium nie wszystko zostało zatrzymane). To mi się udało:

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

Aby zabić proces za pomocą słowa kluczowego midori, Na przykład:

kill -SIGTERM $(pgrep -i midori)

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

Metoda wykorzystująca tylko awk (i ps):

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

Za pomocą string equality testing zapobiegam dopasowaniu tego procesu.

Give-f to pkill

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

Dokładna ścieżka pliku. py to

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

Rozwiązanie byłoby filtrowaniem procesów za pomocą dokładnego wzorca , analizowaniem pid i konstruowaniem listy argumentów do wykonywania procesów kill:

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

Wyjaśnienie z dokumentu:

Ps narzędzie wyświetla linię nagłówka, a następnie linie zawierające informacje o wszystkich procesach, które mają terminale sterujące.

-e Wyświetlanie informacji o procesach innych użytkowników, w tym tych

-f wyświetla uid, pid, PID nadrzędny, Ostatnie użycie procesora, start procesu

Narzędzie grep przeszukuje wszystkie podane pliki wejściowe, wybierając linie, które

-e pattern, --regexp = pattern Określ wzorzec używany podczas wyszukiwania wejścia: Wejście linia jest zaznaczona, jeśli pasuje do któregokolwiek z podanych wzorców. Ta opcja jest najbardziej przydatna, gdy wiele opcji-e jest używanych do określić wiele wzorów lub gdy wzór zaczyna się myślnikiem (`-').

Xargs - konstruuj listę argumentów i wykonuj narzędzie

Kill - zakończenie lub sygnał procesu

Liczba 9 signal-KILL (nie-catchable, nie-ignorable kill)

Przykład :

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

Zacząłem używać czegoś takiego:

kill $(pgrep 'python csp_build.py')

Kill our own processes started from a common PPID is questly, pkill associated to the –P flag is a winner for me. Przykład @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

Nie potrzebujesz przełącznika użytkownika dla ps.

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

W niektórych przypadkach chciałbym zabić procesy simutaneously w ten sposób:

➜  ~  sleep 1000 &
[1] 25410
➜  ~  sleep 1000 &
[2] 25415
➜  ~  sleep 1000 &
[3] 25421
➜  ~  pidof sleep
25421 25415 25410
➜  ~  kill `pidof sleep`
[2]  - 25415 terminated  sleep 1000                                                             
[1]  - 25410 terminated  sleep 1000
[3]  + 25421 terminated  sleep 1000

Jeśli pkill -f csp_build.py nie zabije procesu, możesz dodać -9, Aby wysłać sygnał kill, który nie będzie ignorowany. tj. pkill -9 -f csp_build.py

Używam tego do zabicia Firefoksa, gdy jest on trzaskany skryptem i atakowany cpu :) Zamień "Firefox" na aplikację, którą chcesz umrzeć. Jestem na powłoce Bash-OS X 10.9.3.

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

Używam gkill processname, Gdzie gkill jest następującym skryptem:

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

Uwaga: nie zabije procesów, które mają "grep" w swoich wierszach poleceń.

Użycie flagi -C z polecenia ps

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

Pierwszy przypadek, polecenie proste

Więc jeśli uruchomisz swój skrypt przez standardowy shebang i wywołasz je po jego imieniu:

/path/to/csp_build.py

You may find them whith

ps -C csp_build.py

Więc

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

Druga sprawa, Szukaj cmd

Trochę silniejszy, ale i tak dużo szybszy niż większość innych odpowiedzi na to pytanie...

If you don ' t know ho this is run, or if you run them by

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

Możesz je znaleźć po uruchomieniu:

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

Następnie używając sed:

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

Przyda się następujące polecenie:

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

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

Jeśli proces nadal jest zablokowany, użyj rozszerzenia" -9 " do hardkill, w następujący sposób:

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

Znajdź i zabij wszystkie procesy w jednej linii w bash.

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

• ps -ef | grep '<exe_name>' - Wyświetla listę uruchomionych procesów (uname, pid, itd.), które pasują do wzorca. Lista wyjściowa zawiera również polecenie grep, które je przeszukuje. Teraz dla zabijania musimy zignorować ten grep proces dowodzenia.
• ps -ef | grep '<exec_name>' | grep -v 'grep' - dodanie kolejnego grepa za pomocą -v 'grep' usuwa bieżący proces grepa.
• następnie używając awk uzyskaj sam identyfikator procesu.
• następnie zachowaj to polecenie w środku $(...) i przekazać do kill komendy, aby zabić cały proces.

Możesz użyć poniższego polecenia, aby wyświetlić listę pid polecenia. Użyj top lub lepiej Użyj htop, aby wyświetlić wszystkie procesy w Linuksie. Tutaj chcę zabić proces o nazwie

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

I zweryfikować pid. To musi być proper.To zabij ich za pomocą polecenia Zabij.

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

NP: - jest z listy procesów htop.

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