Quelle est la meilleure façon d'envoyer un signal à tous les membres d'un groupe de processus?

Tuer tous les processus appartenant à la même arborescence des processus à l'aide de la Processus d'ID de Groupe (PGID)

• kill -- -$PGID     Utiliser la valeur par défaut du signal (TERM = 15)
• kill -9 -$PGID     Utiliser le signal KILL (9)

Vous pouvez récupérer le PGID de toute ID du Processus (PID) de la même arborescence des processus

• kill -- -$(ps -o pgid= $PID | grep -o '[0-9]*')   (signal TERM)
• kill -9 -$(ps -o pgid= $PID | grep -o '[0-9]*')   (signal KILL)

^{merci Spécial à tangara et Speakus pour les contributions sur $PID espaces restants et OSX compatibilité.}

Explication

• kill -9 -"$PGID" => Envoyer un signal 9 (KILL) à tous les enfants et petits-enfants...
• PGID=$(ps opgid= "$PID") => Récupérer le Processus-Group-ID de toute ID du Processus de l'arbre, non seulement la Processus Parent-ID. Une variation de ps opgid= $PID est ps -o pgid --no-headers $PID où pgid peut être remplacé par pgrp.
  Mais:
  • ps insère des espaces lorsque PID est à moins de cinq chiffres et aligné à droite comme remarqué par tangara. Vous pouvez utiliser:
    PGID=$(ps opgid= "$PID" | tr -d ' ')
  • ps à partir de OSX toujours imprimer l'en-tête, donc Speakus propose:
    PGID="$( ps -o pgid "$PID" | grep [0-9] | tr -d ' ' )"
• grep -o [0-9]* tirages successifs des chiffres (ne pas imprimer des espaces ou alphabétique des en-têtes).

Plus de lignes de commande

PGID=$(ps -o pgid= $PID | grep -o [0-9]*)
kill -TERM -"$PGID"  # kill -15
kill -INT  -"$PGID"  # correspond to [CRTL+C] from keyboard
kill -QUIT -"$PGID"  # correspond to [CRTL+\] from keyboard
kill -CONT -"$PGID"  # restart a stopped process (above signals do not kill it)
sleep 2              # wait terminate process (more time if required)
kill -KILL -"$PGID"  # kill -9 if it does not intercept signals (or buggy)

Limitation

• Comme remarqué par davide et Hubert Kario, quand kill est invoquée par un processus appartenant au même arbre, kill risques de tuer lui-même avant de mettre fin à l'ensemble de l'arbre de tuer.
• Donc, assurez-vous d'exécuter la commande à l'aide d'un processus ayant une autre Processus-Group-ID.

---

Longue histoire

> cat run-many-processes.sh
#!/bin/sh
echo "ProcessID=$$ begins ($0)"
./child.sh background &
./child.sh foreground
echo "ProcessID=$$ ends ($0)"

> cat child.sh
#!/bin/sh
echo "ProcessID=$$ begins ($0)"
./grandchild.sh background &
./grandchild.sh foreground
echo "ProcessID=$$ ends ($0)"

> cat grandchild.sh
#!/bin/sh
echo "ProcessID=$$ begins ($0)"
sleep 9999
echo "ProcessID=$$ ends ($0)"

Exécuter l'arborescence des processus en arrière-plan à l'aide de " &"

> ./run-many-processes.sh &    
ProcessID=28957 begins (./run-many-processes.sh)
ProcessID=28959 begins (./child.sh)
ProcessID=28958 begins (./child.sh)
ProcessID=28960 begins (./grandchild.sh)
ProcessID=28961 begins (./grandchild.sh)
ProcessID=28962 begins (./grandchild.sh)
ProcessID=28963 begins (./grandchild.sh)
> PID=$!                    # get the Parent Process ID
> PGID=$(ps opgid= "$PID")  # get the Process Group ID
> ps fj
PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
28348 28349 28349 28349 pts/3    28969 Ss   33021   0:00 -bash
28349 28957 28957 28349 pts/3    28969 S    33021   0:00  \_ /bin/sh ./run-many-processes.sh
28957 28958 28957 28349 pts/3    28969 S    33021   0:00  |   \_ /bin/sh ./child.sh background
28958 28961 28957 28349 pts/3    28969 S    33021   0:00  |   |   \_ /bin/sh ./grandchild.sh background
28961 28965 28957 28349 pts/3    28969 S    33021   0:00  |   |   |   \_ sleep 9999
28958 28963 28957 28349 pts/3    28969 S    33021   0:00  |   |   \_ /bin/sh ./grandchild.sh foreground
28963 28967 28957 28349 pts/3    28969 S    33021   0:00  |   |       \_ sleep 9999
28957 28959 28957 28349 pts/3    28969 S    33021   0:00  |   \_ /bin/sh ./child.sh foreground
28959 28960 28957 28349 pts/3    28969 S    33021   0:00  |       \_ /bin/sh ./grandchild.sh background
28960 28964 28957 28349 pts/3    28969 S    33021   0:00  |       |   \_ sleep 9999
28959 28962 28957 28349 pts/3    28969 S    33021   0:00  |       \_ /bin/sh ./grandchild.sh foreground
28962 28966 28957 28349 pts/3    28969 S    33021   0:00  |           \_ sleep 9999
28349 28969 28969 28349 pts/3    28969 R+   33021   0:00  \_ ps fj

La commande pkill -P $PID ne pas tuer le petit-fils:

> pkill -P "$PID"
./run-many-processes.sh: line 4: 28958 Terminated              ./child.sh background
./run-many-processes.sh: line 4: 28959 Terminated              ./child.sh foreground
ProcessID=28957 ends (./run-many-processes.sh)
[1]+  Done                    ./run-many-processes.sh
> ps fj
PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
28348 28349 28349 28349 pts/3    28987 Ss   33021   0:00 -bash
28349 28987 28987 28349 pts/3    28987 R+   33021   0:00  \_ ps fj
1 28963 28957 28349 pts/3    28987 S    33021   0:00 /bin/sh ./grandchild.sh foreground
28963 28967 28957 28349 pts/3    28987 S    33021   0:00  \_ sleep 9999
1 28962 28957 28349 pts/3    28987 S    33021   0:00 /bin/sh ./grandchild.sh foreground
28962 28966 28957 28349 pts/3    28987 S    33021   0:00  \_ sleep 9999
1 28961 28957 28349 pts/3    28987 S    33021   0:00 /bin/sh ./grandchild.sh background
28961 28965 28957 28349 pts/3    28987 S    33021   0:00  \_ sleep 9999
1 28960 28957 28349 pts/3    28987 S    33021   0:00 /bin/sh ./grandchild.sh background
28960 28964 28957 28349 pts/3    28987 S    33021   0:00  \_ sleep 9999

La commande kill -- -$PGID tue tous les processus, y compris le petit-enfant.

> kill --    -"$PGID"  # default signal is TERM (kill -15)
> kill -CONT -"$PGID"  # awake stopped processes
> kill -KILL -"$PGID"  # kill -9 to be sure
> ps fj
PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND
28348 28349 28349 28349 pts/3    29039 Ss   33021   0:00 -bash
28349 29039 29039 28349 pts/3    29039 R+   33021   0:00  \_ ps fj

Conclusion

Je remarque que dans cet exemple PID et PGID sont égaux (28957).

C'est pourquoi j'ai pensé à l'origine kill -- -$PID était assez. Mais dans le cas où le processus est spawn dans un Makefile la ID de Processus est différente de la ID de Groupe.

Je pense que kill -- -$(ps -o pgid= $PID | grep -o [0-9]*) est le meilleur truc simple pour tuer un processus d'ensemble de l'arbre lorsqu'il est appelé à partir d'un autre ID de Groupe (un autre processus de l'arbre).

OriginalL'auteur olibre

De tuer un processus arbre de manière récursive, l'utilisation killtree():

#!/bin/bash
killtree() {
local _pid=$1
local _sig=${2:--TERM}
kill -stop ${_pid} # needed to stop quickly forking parent from producing children between child killing and parent killing
for _child in $(ps -o pid --no-headers --ppid ${_pid}); do
killtree ${_child} ${_sig}
done
kill -${_sig} ${_pid}
}
if [ $# -eq 0 -o $# -gt 2 ]; then
echo "Usage: $(basename $0) <pid> [signal]"
exit 1
fi
killtree $@

OriginalL'auteur zhigang

brad réponse est ce que j'avais trop recommander, sauf que vous pouvez faire disparaître awk tout à fait si vous utilisez le --ppid option pour ps.

for child in $(ps -o pid -ax --ppid $PPID) do ....... done

OriginalL'auteur Kim Stebel

J'utilise un peu une version modifiée de la méthode décrite ici:
https://stackoverflow.com/a/5311362/563175

De sorte qu'il ressemble à ça:

kill `pstree -p 24901 | sed 's/(/\n(/g' | grep '(' | sed 's/(\(.*\)).*/\1/' | tr "\n" " "`

où 24901 est parent PID.

Assez laid, mais est-il du travail à la perfection.

OriginalL'auteur Tomasz Werszko

À ajouter à Norman Ramsey réponse, il peut être intéressant de regarder à setsid si vous souhaitez créer un groupe de processus.

http://pubs.opengroup.org/onlinepubs/009695399/functions/setsid.html

Le setsid() la fonction est de créer un
nouvelle session, si le processus appelant est
pas un processus de chef de groupe. Sur
de retour du processus appelant doit être
le leader de la session de cette nouvelle
session, est le groupe de processus
chef de file d'un nouveau processus de groupe, et
ne ont pas de terminal de contrôle.
Le groupe de processus d'ID de l'appelant
le processus doit être égale à la
ID de processus du processus appelant. L'
processus appelant doit être la seule
processus dans le nouveau processus de groupe et
le seul lors de la nouvelle session.

Qui, pour moi, signifie que vous pouvez créer un groupe à partir de ce processus. J'ai utilisé ce en php afin d'être en mesure de tuer un processus d'ensemble de l'arbre après le démarrage.

Cela peut être une mauvaise idée. Je serais intéressé par les commentaires.

OriginalL'auteur hajamie

Inspiré par ysth commentaire

kill -- -PGID

au lieu de donner un numéro de processus, de lui donner la négation du groupe
numéro. Comme d'habitude avec presque n'importe quelle commande, si vous voulez un argument que la normale
commence avec un - pour ne pas être interprété comme un interrupteur, faites-la précéder d' --

OriginalL'auteur Steven Penny

Il est super facile à faire avec python à l'aide de psutil. Il suffit d'installer psutil avec pip et puis vous avez une gamme complète de processus d'outils de manipulation:

def killChildren(pid):
parent = psutil.Process(pid)
for child in parent.get_children(True):
if child.is_running():
child.terminate()

OriginalL'auteur genericdave

Si vous voulez tuer un processus par nom:

killall -9 -g someprocessname

ou

pgrep someprocessname | xargs pkill -9 -g

OriginalL'auteur Mika Vatanen

Ici est une variante de @zhigang de la réponse, qui n'est sans AWK, en ne s'appuyant que sur le coup de l'analyse native possibilités:

function killtree {
kill -STOP "$1"
ps -e -o pid= -o ppid= | while read -r pid ppid
do
[[ $ppid = $1 ]] || continue
killtree "$pid"  || true # Skip over failures
done
kill -CONT "$1"          
kill -TERM "$1"
}

Il semble fonctionner sur les ordinateurs Mac et Linux. Dans les situations où vous ne pouvez pas compter sur d'être en mesure de gérer les groupes de processus-comme lors de l'écriture de scripts pour tester un morceau de logiciel qui doit être construit dans de multiples environnements -- cet arbre-la marche technique est certainement utile.

OriginalL'auteur solidsnack

Ce qui suit a été testé sur FreeBSD, Linux et MacOS X et ne dépend que de pgrep et de tuer (le ps -o versions ne fonctionnent pas sous BSD). Le premier argument est le parent pid dont les enfants doivent être résilié. deuxième argument est une valeur booléenne pour déterminer si le parent pid doit être arrêté trop.

KillChilds() {
local pid="${1}"
local self="${2:-false}"
if children="$(pgrep -P "$pid")"; then
for child in $children; do
KillChilds "$child" true
done
fi
if [ "$self" == true ]; then
kill -s SIGTERM "$pid" || (sleep 10 && kill -9 "$pid" &)
fi
}
KillChilds $$ > /dev/null 2>&1

Envoyer SIGTERM à tout enfant ou le petit-processus au sein d'un script shell et si SIGTERM ne réussit pas, il faudra attendre 10 secondes et ensuite l'envoyer tuer.

---

Antérieure réponse:

Suivantes fonctionne aussi mais va tuer le shell lui-même sur BSD.

KillSubTree() {
local parent="${1}"
for child in $(ps -o pid=$parent); do
if [ $$ -ne $child ]; then (kill -s SIGTERM $child || (sleep 10 && kill -9 $child & )) > /dev/null 2>&1 ; fi
done
}
# Example lanch from within script
KillSubTree $$ > /dev/null 2>&1

OriginalL'auteur Orsiris de Jong

Vieille question, je sais, mais toutes les réponses semblent garder l'appelant ps, je n'ai pas aimé.

Ce awk-fondé de la solution ne nécessite pas de récursivité et seuls les appels ps la fois.

awk 'BEGIN {
p=1390
while ("ps -o ppid,pid"|getline) a[$1]=a[$1]" "$2
o=1
while (o==1) {
o=0
split(p, q, " ")
for (i in q) if (a[q[i]]!="") {
p=p""a[q[i]]
o=1
a[q[i]]=""
}
}
system("kill -TERM "p)
}'

Ou sur une seule ligne:

awk 'BEGIN {p=1390;while ("ps -o ppid,pid"|getline) a[$1]=a[$1]" "$2;o=1;while (o==1) {o=0;split(p, q, " ");for (i in q) {if (a[q[i]]!="") {p=p""a[q[i]];o=1;a[q[i]]=""}}}system("kill -TERM "p)}'

L'idée de base est que nous construisons un tableau (a), de la mère de l'enfant:les entrées, puis la boucle autour de la matrice de trouver des enfants pour notre correspondance des parents, en les ajoutant à nos parents liste (p) que nous allons.

Si vous ne voulez pas tuer le premier niveau du processus, puis de le faire

sub(/[0-9]*/, "", p)

juste avant que le système() de la ligne de l'enlèverait de la tuer ensemble.

Garder à l'esprit qu'il existe une condition de course ici, mais c'est vrai (aussi loin que je peux voir) de toutes les solutions. Il le fait ce dont j'avais besoin, parce que le script que j'ai besoin d'elle pour ne pas créer des lots de courte durée de vie des enfants.

Un exercice pour le lecteur d'en faire une 2-passer en boucle: après la première passe, envoyer SIGSTOP à tous les processus dans le p de la liste, puis la boucle pour exécuter ps de nouveau et après le deuxième passage, envoyer SIGTERM, puis son état. Si vous n'avez pas de soins sur nice terminaisons puis deuxième passage pourrait être simplement SIGKILL, je suppose.

OriginalL'auteur Whinger

si vous avez pstree et perl sur votre système, vous pouvez essayer ceci:

perl -e 'kill 9, (`pstree -p PID` =~ m/\((\d+)\)/sg)'

OriginalL'auteur lyman

ps -o pid= --ppid $PPID | xargs kill -9 

OriginalL'auteur

Tuer processus enfant dans un shell script:

Beaucoup de temps, nous avons besoin de tuer le processus enfant qui sont pendus ou de bloquer pour une raison quelconque. par exemple. FTP problème de connexion.

Il y a deux approches,

1) Pour créer des nouveaux parents pour chaque enfant qui sera chargé de surveiller et de tuer les processus enfant une fois le délai atteint.

Créer test.sh comme suit,

#!/bin/bash
declare -a CMDs=("AAA" "BBB" "CCC" "DDD")
for CMD in ${CMDs[*]}; do
(sleep 10 & PID=$!; echo "Started $CMD => $PID"; sleep 5; echo "Killing $CMD => $PID"; kill $PID; echo "$CMD Completed.") &
done
exit;

et de regarder les processus qui ont un nom 'test' dans d'autres terminaux utilisant la commande suivante.

watch -n1 'ps x -o "%p %r %c" | grep "test" '

Script ci-dessus va créer 4 nouveaux processus enfants et de leurs parents. Chaque processus enfant continuera de fonctionner pendant 10sec. Mais une fois le délai d'attente de 5 secondes, d'atteindre, de leurs parents respectifs processus de tuer ceux childs.
Si l'enfant ne sera pas en mesure de terminer l'exécution(10sec).
Jouer autour de ces horaires(switch 10 et 5) de voir un autre comportement. Dans ce cas, l'enfant va se terminer l'exécution en 5sec avant qu'il n'atteigne délai de 10sec.

2) Laisser le parent actuel contrôler et tuer des processus enfant une fois le délai atteint. Cela ne crée pas de séparer les parents de surveiller chaque enfant. Aussi, vous pouvez gérer tous les processus fils correctement dans le même parent.

Créer test.sh comme suit,

#!/bin/bash
declare -A CPIDs;
declare -a CMDs=("AAA" "BBB" "CCC" "DDD")
CMD_TIME=15;
for CMD in ${CMDs[*]}; do
(echo "Started..$CMD"; sleep $CMD_TIME; echo "$CMD Done";) &
CPIDs[$!]="$RN";
sleep 1;
done
GPID=$(ps -o pgid= $$);
CNT_TIME_OUT=10;
CNT=0;
while (true); do
declare -A TMP_CPIDs;
for PID in "${!CPIDs[@]}"; do
echo "Checking "${CPIDs[$PID]}"=>"$PID;
if ps -p $PID > /dev/null ; then
echo "-->"${CPIDs[$PID]}"=>"$PID" is running..";
TMP_CPIDs[$PID]=${CPIDs[$PID]};
else
echo "-->"${CPIDs[$PID]}"=>"$PID" is completed.";
fi
done
if [ ${#TMP_CPIDs[@]} == 0 ]; then
echo "All commands completed.";
break;
else
unset CPIDs;
declare -A CPIDs;
for PID in "${!TMP_CPIDs[@]}"; do
CPIDs[$PID]=${TMP_CPIDs[$PID]};
done
unset TMP_CPIDs;
if [ $CNT -gt $CNT_TIME_OUT ]; then
echo ${CPIDs[@]}"PIDs not reponding. Timeout reached $CNT sec. killing all childern with GPID $GPID..";
kill -- -$GPID;
fi
fi
CNT=$((CNT+1));
echo "waiting since $b secs..";
sleep 1;
done
exit;

et de regarder les processus qui ont un nom 'test' dans d'autres terminaux utilisant la commande suivante.

watch -n1 'ps x -o "%p %r %c" | grep "test" '

Script ci-dessus va créer 4 nouveaux processus enfant. Nous sommes de stockage des pids de tous les processus enfant et de boucle pour vérifier si ils ont fini de leur exécution ou en cours d'exécution.
Processus enfant d'exécution jusqu'à CMD_TIME temps. Mais si CNT_TIME_OUT délai d'attente , Tous les enfants seront tués par les processus parent.
Vous pouvez changer de calendrier et de jouer avec le script pour voir le comportement.
Un inconvénient de cette approche est , c'est à l'aide de l'id de groupe pour tuer tous les enfants de l'arbre. Mais le processus parent lui-même appartiennent à un même groupe, donc il sera également se faire tuer.

Vous devrez peut-être attribuer d'autres id du groupe de processus parent si vous ne voulez pas parent d'être tué.

Plus de détails peuvent être trouvés ici,

Tuer le processus enfant en script shell

OriginalL'auteur Hemant Thorat

Je sais que c'est vieux, mais c'est la meilleure solution que j'ai trouvé:

killtree() { 
for p in $(pstree -p $1 | grep -o "([[:digit:]]*)" |grep -o "[[:digit:]]*" | tac);do
echo Terminating: $p 
kill $p
done
}

OriginalL'auteur Luciano Andress Martini