validate - Encuentra y elimina un proceso en una línea usando bash y regex

regex text between tags

Question

A menudo necesito matar un proceso durante la programación.

La forma en que lo hago ahora es:

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

¿Cómo puedo extraer la identificación del proceso automáticamente y matarlo en la misma línea?

Me gusta esto:

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

Answer 1

Un trazador de líneas:

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

• Imprima la columna 2: awk ''{print $2}''
• sudo es opcional
• Ejecute kill -9 5124 , kill -9 5373 etc. (kill -15 es más elegante pero un poco más lento)

Prima:

También tengo 2 funciones de acceso directo definidas en mi .bash_profile (~ / .bash_profile es para osx, tienes que ver qué funciona para tu máquina * nix).

1. p palabra clave
   • Enumera todos los P que contienen palabras clave
   • uso, por ejemplo: p csp_build , p python etc.

código bash_profile:

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

2. palabra clave ka
   • K ills A ll procesa esta palabra clave.
   • uso, por ejemplo: ka csp_build , ka python etc.
   • nivel de eliminación opcional, por ejemplo: ka csp_build 15 , ka python 9

código 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"
}

Answer 2

Comencé a usar algo como esto:

kill $(pgrep ''python csp_build.py'')

Answer 3

Dar -f a pkill

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

La ruta exacta del archivo .py es

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

Answer 4

El siguiente comando será útil:

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

por ejemplo, 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

Si el proceso sigue bloqueado, use la extensión "-9" para hardkill, de la siguiente manera:

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

Espero que ayude...!

Answer 5

En bash , deberías poder hacer:

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

Los detalles sobre su funcionamiento son los siguientes:

• El ps te da la lista de todos los procesos.
• Los filtros grep que se basan en su cadena de búsqueda, [p] es un truco para evitar que retire el proceso real de grep .
• El awk solo le da el segundo campo de cada línea, que es el PID.
• La construcción $(x) significa ejecutar x luego tomar su salida y colocarla en la línea de comando. La salida de esa tubería ps dentro de la construcción anterior es la lista de ID de procesos, por lo que terminas con un comando como kill 1234 1122 7654 .

Aquí hay una transcripción que lo muestra en acción:

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

Y lo puedes ver terminando todos los durmientes.

Explicando el bit grep ''[p]ython csp_build.py'' con un poco más de detalle:

Cuando sleep 3600 & seguido por ps -ef | grep sleep ps -ef | grep sleep , tiendes a tener dos procesos con sleep , el sleep 3600 y el grep sleep (porque los dos tienen sleep , eso no es ciencia espacial).

Sin embargo, ps -ef | grep ''[s]leep'' ps -ef | grep ''[s]leep'' no creará un proceso con el sleep , sino que crea grep ''[s]leep'' y aquí está el grep ''[s]leep'' : el grep no lo encuentra porque está buscando la expresión regular "cualquier Carácter de la clase de caracteres [s] (que es s ) seguido de un leep .

En otras palabras, está buscando sleep pero el proceso grep es grep ''[s]leep'' que no tiene sleep .

Cuando me mostraron esto (por alguien aquí en SO), inmediatamente comencé a usarlo porque

• Es un proceso menos que agregar | grep -v grep | grep -v grep ; y
• es elegante y astuto, una combinación rara :-)

Answer 6

En algunos casos, me gustaría matar procesos simultáneamente de esta manera:

➜ ~ 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

Pero, creo que es un poco inapropiado en tu caso. (Puede que estén ejecutando python a, python b, python x ... en el fondo).

Answer 7

Encuentra y mata todos los procesos en una sola línea en bash.

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

• ps -ef | grep ''<exe_name>'' ps -ef | grep ''<exe_name>'' : proporciona la lista de detalles del proceso en ejecución (uname, pid, etc.) que coincide con el patrón. La lista de salida incluye este comando grep que también lo busca. Ahora para matar necesitamos ignorar este proceso de comando grep .
• ps -ef | grep ''<exec_name>'' | grep -v ''grep'' ps -ef | grep ''<exec_name>'' | grep -v ''grep'' : agregar otro grep con -v ''grep'' elimina el proceso actual de grep.
• Entonces usando awk obtén el identificador de proceso solo.
• Luego, mantenga este comando dentro de $(...) y páselo al comando kill , para eliminar todo el proceso.

Answer 8

Intenta usar

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

Answer 9

Matar nuestros propios procesos iniciados a partir de un PPID común es bastante frecuente, pkill asociado a la –P es un ganador para mí. Usando el ejemplo de @ 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

Answer 10

Mi tarea fue eliminar todo lo que coincida con la expresión regular que se coloca en un directorio específico (después de las pruebas de selenio no se detuvo todo) Esto funcionó para mí:

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

Answer 11

No necesitas el cambio de usuario para ps.

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

Answer 12

Para matar proceso por palabra clave midori , por ejemplo:

kill -SIGTERM $(pgrep -i midori)

Answer 13

Puede usar el siguiente comando para enumerar el pid del comando. Use top o mejor use htop para ver todos los procesos en linux. Aquí quiero matar un proceso llamado

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

Y verificar el pid. Debe ser apropiado. Para matarlos, use el comando kill.

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

Por ejemplo: - es de la lista de procesos htop.

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

Esto resuelve mis problemas. Siempre esté preparado para reiniciar el proceso si accidentalmente mata un proceso.

Answer 14

Puedes hacerlo con awk y backtics.

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

$ 2 en awk imprime la columna 2, y el backtics ejecuta la declaración que se imprimió.

Pero una solución mucho más limpia sería que el proceso de Python almacenara su ID de proceso en / var / run y luego simplemente puede leer ese archivo y eliminarlo.

Answer 15

Puedes usar solo pkill ''^python*'' para matar el proceso de expresiones regulares.

Si desea ver lo que matará o encontrará antes de matarlo, simplemente use pgrep -l ''^python*'' donde -l muestra también el nombre del proceso. Si no quieres usar pkill , usa solo:

pgrep ''^python*'' | xargs kill

Answer 16

Un método que usa solo awk (y ps ):

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

Mediante el uso de pruebas de igualdad de cadenas, evito hacer coincidir este proceso.

Answer 17

Use pgrep - disponible en muchas plataformas:

kill -9 `pgrep -f cps_build`

pgrep -f devolverá todos los PID con coincidencia "cps_build"

Answer 18

Uso gkill processname , donde gkill es el siguiente 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: NO eliminará los procesos que tengan "grep" en sus líneas de comando.

Answer 19

Utilizo esto para matar a Firefox cuando se está cerrando de golpe el script y golpeando a la CPU :) Reemplaza ''Firefox'' con la aplicación que quieres morir. Estoy en el shell Bash - OS X 10.9.3 Darwin.

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

Answer 20

si tienes pkill,

pkill -f csp_build.py

Si solo desea grep contra el nombre del proceso (en lugar de la lista de argumentos completa), deje de -f .

Answer 21

killall -r regexp
-r, --regexp

Interprete el patrón de nombre de proceso como una expresión regular extendida.

Answer 22

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