等待进程完成

Question

Bash 中是否有任何内置功能可以等待进程完成？

wait 命令只允许等待子进程完成。 我想知道是否有任何方法可以在继续执行任何脚本之前等待任何进程完成。

执行此操作的机械方法如下，但我想知道 Bash 中是否有任何内置功能。

while ps -p `cat $PID_FILE` > /dev/null; do sleep 1; done

Answer 1

在像 OSX 这样的系统上，您可能没有 pgrep，因此您可以在按名称查找进程时尝试此方法：

while ps axg | grep process_name$ > /dev/null; do sleep 1; done

进程名称末尾的 $ 符号确保 grep 仅匹配 process_name 到末尾ps 输出中的行而不是其本身。

Answer 2

等待任何进程完成

Linux（在 Alpine 上不起作用，其中 ash 不支持 tail --pid）：

tail --pid=$pid -f /dev/null

Darwin（要求 $pid 已打开文件）：

lsof -p $pid +r 1 &>/dev/null

超时（秒）

Linux：

timeout $timeout tail --pid=$pid -f /dev/null

Darwin（要求 $pid 有打开的文件）：

lsof -p $pid +r 1m%s -t | grep -qm1 $(date -v+${timeout}S +%s 2>/dev/null || echo INF)

Answer 3

没有内置的。 在循环中使用 kill -0 以获得可行的解决方案：

anywait(){

    for pid in "$@"; do
        while kill -0 "$pid"; do
            sleep 0.5
        done
    done
}

或者作为更简单的 oneliner 以方便一次性使用：

while kill -0 PIDS 2> /dev/null; do sleep 1; done;

正如几位评论员所指出的，如果您想等待您没有权限的进程要发送信号，您必须找到其他方法来检测进程是否正在运行来替换 kill -0 $pid 调用。 在 Linux 上，test -d "/proc/$pid" 可以工作，在其他系统上，您可能必须使用 pgrep （如果可用）或类似 ps | 的东西。 grep“^$pid”。

Answer 4

我发现如果进程由 root（或其他）拥有，“kill -0”不起作用，因此我使用 pgrep 并提出：

while pgrep -u root process_name > /dev/null; do sleep 1; done

这可能具有可能匹配僵尸进程的缺点。

Answer 5

如果进程不存在或者是僵尸进程，则该 bash 脚本循环结束。

PID=<pid to watch>
while s=`ps -p $PID -o s=` && [[ "$s" && "$s" != 'Z' ]]; do
    sleep 1
done

编辑：上面的脚本给出如下< /a> 作者：Rockallite。 谢谢！

我下面的原始答案适用于 Linux，依赖于 procfs 即 /proc/。 我不知道它的可移植性：

while [[ ( -d /proc/$PID ) && ( -z `grep zombie /proc/$PID/status` ) ]]; do
    sleep 1
done

它不仅限于shell，而且操作系统本身没有系统调用来监视非子进程终止。

Answer 6

FreeBSD 和 Solaris 有这个方便的 pwait(1) 实用程序，它完全可以满足您的需求。

我相信，其他现代操作系统也有必要的系统调用（例如，MacOS 实现了 BSD 的 kqueue），但并非所有操作系统都可以从命令行使用它。

Answer 7

来自 bash 联机帮助页

   wait [n ...]
          Wait for each specified process and return its termination  status
          Each  n  may be a process ID or a job specification; if a
          job spec is given, all processes  in  that  job's  pipeline  are
          waited  for.  If n is not given, all currently active child processes
          are waited for, and the return  status  is  zero.   If  n
          specifies  a  non-existent  process or job, the return status is
          127.  Otherwise, the return status is the  exit  status  of  the
          last process or job waited for.

Answer 8

所有这些解决方案都在 Ubuntu 14.04 中进行了测试：

解决方案 1（通过使用 ps 命令）：
为了补充 Pierz 的答案，我建议：

while ps axg | grep -vw grep | grep -w process_name > /dev/null; do sleep 1; done

在这种情况下，grep -vw grep 确保 grep 仅匹配 process_name 而不是 grep 本身。 它的优点是支持 process_name 不在 ps axg 行尾的情况。

解决方案 2（使用 top 命令和进程名称）：

while [[ $(awk '$12=="process_name" {print $0}' <(top -n 1 -b)) ]]; do sleep 1; done

将 process_name 替换为 top -n 1 -b 中出现的进程名称。 请保留引号。

要查看等待完成的进程列表，您可以运行：

while : ; do p=$(awk '$12=="process_name" {print $0}' <(top -n 1 -b)); [[ $b ]] || break; echo $p; sleep 1; done

解决方案 3（通过使用 top 命令和进程 ID）：

while [[ $(awk '$1=="process_id" {print $0}' <(top -n 1 -b)) ]]; do sleep 1; done

将 process_id 替换为进程您的程序的 ID。

Answer 9

好吧，看来答案是——不，没有内置工具。

将/proc/sys/kernel/yama/ptrace_scope设置为0后，就可以使用strace程序了。 可以使用更多开关使其保持沉默，以便它真正被动等待：

strace -qqe '' -p <PID>

Answer 10

遇到了同样的问题，我解决了杀死进程然后等待每个进程使用 PROC 文件系统完成的问题：

while [ -e /proc/${pid} ]; do sleep 0.1; done

Answer 11

阻塞解决方案

在循环中使用wait，用于等待终止所有进程：

function anywait()
{

    for pid in "$@"
    do
        wait $pid
        echo "Process $pid terminated"
    done
    echo 'All processes terminated'
}

当所有进程终止时，该函数将立即退出。 这是最有效的解决方案。

非阻塞解决方案

在循环中使用kill -0，等待终止所有进程+在检查之间执行任何操作：

function anywait_w_status()
{
    for pid in "$@"
    do
        while kill -0 "$pid"
        do
            echo "Process $pid still running..."
            sleep 1
        done
    done
    echo 'All processes terminated'
}

反应时间减少到睡眠时间，因为必须防止 CPU 使用率过高。

实际用法：

等待终止所有进程+通知用户所有正在运行的PID。

function anywait_w_status2()
{
    while true
    do
        alive_pids=()
        for pid in "$@"
        do
            kill -0 "$pid" 2>/dev/null \
                && alive_pids+="$pid "
        done

        if [ ${#alive_pids[@]} -eq 0 ]
        then
            break
        fi

        echo "Process(es) still running... ${alive_pids[@]}"
        sleep 1
    done
    echo 'All processes terminated'
}

注释

这些函数通过 $@ 作为 BASH 数组的参数获取 PID。

Answer 12

没有内置功能可以等待任何进程完成。

您可以将 kill -0 发送到任何找到的 PID，这样您就不会被僵尸和在 ps 中仍然可见的东西所困扰（同时仍然检索 PID 列表）使用ps）。

Answer 13

如果您需要终止进程并等待其完成，可以使用 killall(1)（基于进程名称）和 start-stop-daemon(8)（基于 pidfile）。

终止与 someproc 匹配的所有进程并等待它们终止：（

killall someproc --wait             # wait forever until matching processes die
timeout 10s killall someproc --wait # timeout after 10 seconds

不幸的是，对于特定的特定进程，没有 --wait 与 kill 的直接等效项PID）。

使用信号 SIGINT 终止基于 pidfile /var/run/someproc.pid 的进程，同时使用 SIGKILL 等待它完成20 秒超时后发送，使用：

start-stop-daemon --stop --signal INT --retry 20 --pidfile /var/run/someproc.pid

Answer 14

当进程终止时，使用 inotifywait 监视某些关闭的文件。 示例（在 Linux 上）：

yourproc >logfile.log & disown
inotifywait -q -e close logfile.log

-e 指定要等待的事件，-q 表示仅在终止时最小输出。 在这种情况下，它将是：

logfile.log CLOSE_WRITE,CLOSE

单个 wait 命令可用于等待多个进程：

yourproc1 >logfile1.log & disown
yourproc2 >logfile2.log & disown
yourproc3 >logfile3.log & disown
inotifywait -q -e close logfile1.log logfile2.log logfile3.log

inotifywait 的输出字符串将告诉您哪个进程终止。 这只适用于“真实”文件，不适用于 /proc/ 中的内容

Answer 15

Rauno Palosaari 的 Timeout in Seconds Darwin 解决方案对于没有 GNU tail 的类 UNIX 操作系统来说是一个很好的解决方法（它不是具体到达尔文）。 但是，根据类 UNIX 操作系统的年龄，提供的命令行比必要的更复杂，并且可能会失败：

lsof -p $pid +r 1m%s -t | grep -qm1 $(date -v+${timeout}S +%s 2>/dev/null || echo INF)

在至少一个旧的 UNIX 上，lsof 参数 + r 1m%s 失败（即使对于超级用户）：

lsof: can't read kernel name list.

m%s 是输出格式规范。 更简单的后处理器不需要它。 例如，以下命令在 PID 5959 上等待最多五秒：

lsof -p 5959 +r 1 | awk '/^=/ { if (T++ >= 5) { exit 1 } }'

在本示例中，如果 PID 5959 在五秒过去之前自行退出，则 ${?} 为 0。 如果不是，${?} 将在五秒后返回 1。

值得注意的是，在+r 1中，1是轮询间隔（以秒为单位），因此可以根据情况进行更改。