天天看点

向流程组的所有成员发送信号的最佳方法是什么?

我想杀死整个进程树。 使用任何常用脚本语言执行此操作的最佳方法是什么? 我正在寻找一个简单的解决方案。

#1楼

志刚答案的修改版:

#!/usr/bin/env bash
set -eu

killtree() {
    local pid
    for pid; do
        kill -stop $pid
        local cpid
        for cpid in $(pgrep -P $pid); do
            killtree $cpid
        done
        kill $pid
        kill -cont $pid
        wait $pid 2>/dev/null || true
   done
}

cpids() {
    local pid=$1 options=${2:-} space=${3:-}
    local cpid
    for cpid in $(pgrep -P $pid); do
        echo "$space$cpid"
        if [[ "${options/a/}" != "$options" ]]; then
            cpids $cpid "$options" "$space  "
        fi
    done
}

while true; do sleep 1; done &
cpid=$!
for i in $(seq 1 2); do
    cpids $$ a
    sleep 1
done
killtree $cpid
echo ---
cpids $$ a
           

#2楼

受ysth的评论启发

kill -- -PGID
           
与其给它一个进程号,不给它组号。 与几乎所有命令一样,如果您希望以

-

开头的普通参数不被解释为开关,请在其前面加上

--

#3楼

使用进程组ID (

PGID

)杀死属于同一进程树的所有进程

  • kill -- -$PGID

    使用默认信号(

    TERM

    = 15)
  • kill -9 -$PGID

    使用信号

    KILL

    (9)

您可以从同一进程树的任何进程ID (

PID

)中检索

PGID

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

    (信号

    TERM

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

    (信号

    KILL

特别感谢唐加拉雀和Speakus的捐款

$PID

剩余空间和OSX的兼容性。

说明

  • kill -9 -"$PGID"

    =>向所有子孙发送信号9(

    KILL

    )...
  • PGID=$(ps opgid= "$PID")

    =>从树的任何Process-ID中检索Process-Group-ID ,而不仅仅是Process-Parent-ID 。

    ps opgid= $PID

    变体是

    ps -o pgid --no-headers $PID

    ,其中

    pgid

    可以用

    pgrp

    代替。

    但:

    • ps

      PID

      小于五位数且如tanager注意到的那样右对齐时插入前导空格。 您可以使用:

      PGID=$(ps opgid= "$PID" | tr -d ' ')

    • 来自OSX的

      ps

      总是打印标题,因此Speakus建议:

      PGID="$( ps -o pgid "$PID" | grep [0-9] | tr -d ' ' )"

  • grep -o [0-9]*

    仅打印连续的数字(不打印空格或字母头)。

其他命令行

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)
           

局限性

  • 由于注意到了达维德和休伯特Kario ,当

    kill

    由属于同一棵树的过程调用,

    kill

    风险终止整个树杀害前杀死自己。
  • 因此,请确保使用具有不同Process-Group-ID的进程运行命令。

很长的故事

> 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)"
           

使用“&”在后台运行进程树

> ./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
           

命令

pkill -P $PID

不会杀死孙子:

> 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
           

命令

kill -- -$PGID

杀死所有进程,包括孙子进程。

> 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
           

结论

在此示例中,我注意到

PID

PGID

相等(

28957

)。

这就是为什么我最初认为

kill -- -$PID

就足够了。 但是,如果进程在

Makefile

则进程ID与组ID不同。

我认为

kill -- -$(ps -o pgid= $PID | grep -o [0-9]*)

是从另一个组ID (另一个进程树)调用时杀死整个进程树的最佳简单技巧。

#4楼

以下shell函数与许多其他答案类似,但是它可以在Linux和BSD(OS X等)上运行,而无需像

pgrep

这样的外部依赖项:

killtree() {
    local parent=$1 child
    for child in $(ps -o ppid= -o pid= | awk "\$1==$parent {print \$2}"); do
        killtree $child
    done
    kill $parent
}
           

#5楼

使用psutil使用python做到这一点非常容易。 只需将psutil与pip一起安装,即可获得一整套的流程处理工具:

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

#6楼

我不能评论(没有足够的声望),所以我不得不增加一个新的答案 ,尽管这不是一个真正的答案。

@olibre在2月28日给出的否则,可能会得到一个非常好的和彻底的回答,这有一个小问题

ps opgid= $PID

的输出将包含少于五位数的PID的前导空格,因为

ps

使列对齐(数字)。 在整个命令行中,这将导致一个负号,后跟空格,然后是组PID。 一个简单的解决方案是将

ps

传递给

tr

以删除空格:

kill -- -$( ps opgid= $PID | tr -d ' ' )
           

#7楼

根据志刚的回答,这可以避免自我杀戮:

init_killtree() {
    local pid=$1 child

    for child in $(pgrep -P $pid); do
        init_killtree $child
    done
    [ $pid -ne $$ ] && kill -kill $pid
}
           

#8楼

这是@zhigang答案的一种变体,它没有AWK,仅依赖于Bash的本机解析能力:

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

在Mac和Linux上似乎都可以正常工作。 在您不能依赖于能够管理流程组的情况下(例如编写脚本来测试必须在多个环境中构建的软件时),这种遍历树技术无疑会有所帮助。

#9楼

如果要按名称终止进程:

killall -9 -g someprocessname
           

要么

pgrep someprocessname | xargs pkill -9 -g
           

#10楼

在sh中,jobs命令将列出后台进程。 在某些情况下,最好先终止最新的进程,例如较旧的进程创建了一个共享套接字。 在这些情况下,请按相反顺序对PID进行排序。 有时,您需要等待片刻,以便作业在停止之前将其写入磁盘或类似内容。

而且,如果不必,也不要杀死!

for SIGNAL in TERM KILL; do
  for CHILD in $(jobs -s|sort -r); do
    kill -s $SIGNAL $CHILD
    sleep $MOMENT
  done
done
           

#11楼

要递归终止进程树,请使用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 $@
           

#12楼

在shell脚本中杀死子进程:

很多时候我们需要杀死由于某种原因而挂起或阻塞的子进程。 例如。 FTP连接问题。

有两种方法,

1)为每个孩子创建一个单独的新父母,一旦超时,它将监视并杀死孩子进程。

如下创建test.sh,

#!/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;
           

使用以下命令在其他终端中监视名称为“ test”的进程。

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

上面的脚本将创建4个新的子进程及其父母。 每个子进程将运行10秒。 但是一旦达到5秒超时,它们各自的父进程将杀死那些孩子。 因此孩子将无法完成执行(10秒)。 在这些时机(开关10和5)上播放,以查看其他行为。 在这种情况下,子级将在达到10秒超时之前的5秒内完成执行。

2)一旦超时,让当前的父进程监视并杀死子进程。 这不会创建单独的父母来监视每个孩子。 您也可以在同一父级中正确管理所有子进程。

如下创建test.sh,

#!/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;
           

使用以下命令在其他终端中监视名称为“ test”的进程。

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

上面的脚本将创建4个新的子进程。 我们将存储所有子进程的pid,并对其进行循环以检查它们是否已完成执行或仍在运行。 子进程将执行到CMD_TIME时间。 但是,如果CNT_TIME_OUT超时到达,则所有子进程都将被父进程杀死。 您可以切换时间并使用脚本来查看行为。 这种方法的一个缺点是,它使用组ID杀死所有子树。 但是父进程本身属于同一组,因此也会被杀死。

如果您不想杀死父进程,则可能需要将其他组ID分配给父进程。

更多详情可在这找到,

在Shell脚本中杀死子进程

#13楼

以下内容已在FreeBSD,Linux和MacOS X上进行了测试,仅取决于pgrep和kill(ps -o版本在BSD下不起作用)。 第一个参数是必须终止其子级的父级pid。 第二个参数是一个布尔值,用于确定是否也必须终止父pid。

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
           

这会将SIGTERM发送到Shell脚本中的任何子进程/孙进程,如果SIGTERM不成功,它将等待10秒钟,然后发送kill。

较早的答案:

以下内容也可以,但是会杀死BSD上的shell本身。

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
           

#14楼

该脚本也可以工作:

#/bin/sh while true do echo "Enter parent process id [type quit for exit]" read ppid if [ $ppid -eq "quit" -o $ppid -eq "QUIT" ];then exit 0 fi for i in `ps -ef| awk '$3 == '$ppid' { print $2 }'` do echo killing $i kill $i done done

#15楼

如果您的系统上有pstree和perl,则可以尝试以下操作:

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

#16楼

pslist软件包中的rkill命令将给定信号(默认情况下为

SIGTERM

)发送到指定的进程及其所有后代:

rkill [-SIG] pid/name...
           

#17楼

如果您知道传递父进程的pid,这是一个应该起作用的shell脚本:

for child in $(ps -o pid,ppid -ax | \
   awk "{ if ( \$2 == $pid ) { print \$1 }}")
do
  echo "Killing child process $child because ppid = $pid"
  kill $child
done
           

#18楼

布拉德的答案也是我的建议,除了如果对

ps

使用

--ppid

选项,可以完全取消

awk

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

#19楼

您没有说您要杀死的树是否是单个进程组。 (如果树是从服务器启动或shell命令行派生的结果,通常是这种情况。)可以使用GNU ps如下发现进程组:

ps x -o  "%p %r %y %x %c "
           

如果它是您要终止的进程组,则只需使用

kill(1)

命令,但不要给它一个进程号,而要给它取反组号。 例如,要杀死组5112中的每个进程,请使用

kill -TERM -- -5112

#20楼

我将进一步开发zhigang,xyuri和solidsneck的解决方案:

#!/bin/bash

if test $# -lt 1 ; then
    echo >&2 "usage: kiltree pid (sig)"
    exit 1 ;
  fi ;

_pid=$1
_sig=${2:-TERM}

# echo >&2 "killtree($_pid) mypid = $$"
# ps axwwf | grep -6 "^[ ]*$_pid " >&2 ;

function _killtree () {
    local _children
    local _child
    local _success

    if test $1 -eq $2 ; then # this is killtree - don't commit suicide!
        echo >&2 "killtree can´t kill it´s own branch - some processes will survive." ; 
        return 1 ;
      fi ;
    # this avoids that children are spawned or disappear.
    kill -SIGSTOP $2 ;

    _children=$(ps -o pid --no-headers --ppid $2) ;        
    _success=0 
    for _child in ${_children}; do
        _killtree $1 ${_child} $3 ;
        _success=$(($_success+$?)) ;
      done ;

    if test $_success -eq 0 ; then
        kill -$3 $2
      fi ;
    # when a stopped process is killed, it will linger in the system until it is continued
    kill -SIGCONT $2
    test $_success -eq 0 ;
    return $?
    }

_killtree $$ $_pid $_sig
           

此版本将避免杀死其祖先-在先前的解决方案中导致大量子进程。

在确定子级列表之前,进程已正确停止,因此不会创建或消失任何新的子级。

在被杀死之后,停止的作业必须继续从系统中消失。

#21楼

谢谢你的智慧,伙计们。 我的脚本是在退出时保留一些子进程, 否定提示使事情变得更容易。 如有必要,我编写了此函数以供其他脚本使用:

# kill my group's subprocesses:          killGroup
# kill also myself:                      killGroup -x
# kill another group's subprocesses:     killGroup N  
# kill that group all:                   killGroup -x N
# N: PID of the main process (= process group ID).

function killGroup () {
    local prid mainpid
    case $1 in
        -x) [ -n "$2" ] && kill -9 -$2 || kill -9 -$$ ;;
        "") mainpid=$$ ;;
         *) mainpid=$1 ;;
    esac
    prid=$(ps ax -o pid,pgid | grep $mainpid)
    prid=${prid//$mainpid/}
    kill -9 $prid 2>/dev/null
    return
}
           

干杯。

#22楼

我知道这是一个老问题,但是所有的回答似乎都一直在呼唤ps,我不喜欢它。

这种基于awk的解决方案不需要递归,只需调用ps一次即可。

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)
}'
           

或单行:

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)}'
           

基本上,我们的想法是建立一个由parent:child条目组成的数组(a),然后在数组中循环查找匹配的父级的子级,然后将它们添加到我们的父级列表(p)中。

如果您不想终止顶层进程,那么可以这样做

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

就在system()行将其从kill set中删除之前。

请记住,这里有一个竞争条件,但就所有解决方案而言,这都是事实(据我所知)。 它满足了我的需要,因为我需要的脚本不会创建很多短暂的孩子。

读者的一个练习是使其成为2遍循环:在第一遍之后,将SIGSTOP发送到p列表中的所有进程,然后循环以再次运行ps,在第二遍之后发送SIGTERM,然后是SIGCONT。 我想,如果您不在乎出色的结局,那么第二遍可能只是SIGKILL。

#23楼

我知道那是旧的,但这是我发现的更好的解决方案:

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

#24楼

最好先杀掉父母,再杀掉孩子。 否则,父母可能会在杀死自己之前再次生下新孩子。 这些将幸免于难。

我的ps版本与上述版本不同; 也许是太老了,所以奇怪的是...

使用shell脚本而不是shell函数有很多优点...

但是,这基本上是志刚的想法

#!/bin/bash
if test $# -lt 1 ; then
    echo >&2 "usage: kiltree pid (sig)"
fi ;

_pid=$1
_sig=${2:-TERM}
_children=$(ps j | grep "^[ ]*${_pid} " | cut -c 7-11) ;
echo >&2 kill -${_sig} ${_pid}
kill -${_sig} ${_pid}
for _child in ${_children}; do
    killtree ${_child} ${_sig}
done
           

#25楼

如果您知道要杀死的对象的pid,通常可以使用会话ID以及同一会话中的所有内容。 我会仔细检查,但是我将其用于在我想死的循环中启动rsync的脚本,而不是像我只是杀死所有rsync那样启动另一个(由于循环)的脚本。

kill $(ps -o pid= -s $(ps -o sess --no-heading --pid 21709))
           

如果您不知道pid,您仍然可以嵌套更多

kill $(ps -o pid= -s $(ps -o sess --no-heading --pid $(pgrep rsync )))
           

#26楼

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

#27楼

pkill -TERM -P 27888
           

这将杀死所有具有父进程ID 27888的进程。

或更强大:

CPIDS=$(pgrep -P 27888); (sleep 33 && kill -KILL $CPIDS &); kill -TERM $CPIDS
           

计划在33秒后杀死,并礼貌地要求进程终止。

请参阅此答案以终止所有后代。

#28楼

要增加Norman Ramsey的答案,如果您想创建一个流程组,可能值得看一下setid。

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

如果调用进程不是进程组负责人,则setsid()函数应创建一个新会话。 返回时,呼叫进程将是此新会话的会话负责人,应是新进程组的进程组负责人,并且没有控制终端。 调用进程的进程组ID必须设置为等于调用进程的进程ID。 调用进程应是新进程组中的唯一进程,并且是新会话中的唯一进程。

我的意思是,您可以从开始过程中创建一个组。 我在php中使用了它,以便能够在启动它之后杀死整个进程树。

这可能是一个坏主意。 我会对评论感兴趣。

#29楼

这是我使用bash脚本杀死所有子进程的版本。 它不使用递归,并且取决于pgrep命令。

使用

killtree.sh PID SIGNAL
           

killtrees.sh的内容

#!/bin/bash
PID=$1
if [ -z $PID ];
then
    echo "No pid specified"
fi

PPLIST=$PID
CHILD_LIST=`pgrep -P $PPLIST -d,`

while [ ! -z "$CHILD_LIST" ]
do
    PPLIST="$PPLIST,$CHILD_LIST"
    CHILD_LIST=`pgrep -P $CHILD_LIST -d,`
done

SIGNAL=$2

if [ -z $SIGNAL ]
then
    SIGNAL="TERM"
fi
#do substring from comma to space
kill -$SIGNAL ${PPLIST//,/ }
           

#30楼

我使用此处描述的方法的一些修改版本: https : //stackoverflow.com/a/5311362/563175

所以看起来像这样:

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

其中24901是父母的PID。

它看起来很丑,但是做得很好。

继续阅读