Дождитесь окончания процесса

Есть ли в Bash встроенная функция для ожидания завершения процесса?

Команда waitпозволяет только дождаться завершения дочерних процессов. Я хотел бы знать, есть ли какой-либо способ дождаться завершения какого-либо процесса, прежде чем приступить к какому-либо сценарию.

Механический способ сделать это заключается в следующем, но я хотел бы знать, есть ли какая-либо встроенная функция в Bash.

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

Дождаться окончания любого процесса

Linux:

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

Дарвин (требует наличия $pidоткрытых файлов):

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

С таймаутом (в секундах)

Linux:

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

Дарвин (требует наличия $pidоткрытых файлов):

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

Там нет встроенных. Используйте kill -0в цикле для работоспособного решения:

anywait(){

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

Или как более простой способ для простого однократного использования:

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

Как отметили несколько комментаторов, если вы хотите дождаться процессов, на которые у вас нет прав отправлять сигналы, вы найдете другой способ определить, запущен ли процесс, чтобы заменить kill -0 $pidвызов. В Linux test -d "/proc/$pid"работает, в других системах вам, возможно, придется использовать pgrep(если доступно) или что-то подобное ps | grep "^$pid ".

Я обнаружил, что "kill -0" не работает, если процесс принадлежит пользователю root (или другому), поэтому я использовал pgrep и придумал:

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

Это могло бы иметь недостаток, заключающийся в том, чтобы соответствовать процессам зомби.

Этот цикл bash-скрипта заканчивается, если процесс не существует или это зомби.

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

EDIT : Возможно, приведенный выше сценарий был приведен ниже по Rockallite . Спасибо!

Мой оригинальный ответ ниже работает для Linux, полагаясь на procfsто есть /proc/. Я не знаю его переносимость:

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

Это не ограничивается оболочкой, но сами ОС не имеют системных вызовов для наблюдения за завершением не дочерних процессов.

FreeBSD и Solaris имеют эту удобную pwait(1)утилиту, которая делает именно то, что вы хотите.

Я считаю, что другие современные ОС также имеют необходимые системные вызовы (например, MacOS реализует BSD kqueue), но не все делают это доступным из командной строки.

Из man-страницы 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.

Все эти решения протестированы в 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. Преимущество заключается в поддержке случаев, когда имя_процесса находится не в конце строки в 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 и идентификатора процесса):

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

Замените process_idна идентификатор процесса вашей программы.

Итак, похоже, ответ - нет, встроенного инструмента нет.

После установки /proc/sys/kernel/yama/ptrace_scopeна 0, можно использовать straceпрограмму. Другие переключатели могут быть использованы, чтобы заставить его замолчать, чтобы он действительно пассивно ожидал:

strace -qqe '' -p <PID>

Блокирующее решение

Используйте waitцикл in для ожидания завершения всех процессов:

function anywait()
{

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

Эта функция будет завершена немедленно после завершения всех процессов. Это самое эффективное решение.

Неблокирующее решение

Используйте kill -0цикл in, чтобы дождаться завершения всех процессов + сделать что-нибудь между проверками:

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

Время реакции уменьшилось до sleepвремени, потому что нужно предотвратить высокую загрузку процессора.

Реалистичное использование:

Ожидание завершения всех процессов + информирование пользователя обо всех запущенных 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'
}

Ноты

Эти функции получают PID с помощью аргументов в $@виде массива BASH.

У меня была та же проблема, я решил проблему, убив процесс и затем дождавшись завершения каждого процесса с использованием файловой системы PROC:

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

Нет встроенной функции для ожидания завершения какого-либо процесса.

Вы можете отправлять kill -0на любой найденный PID, чтобы вас не озадачили зомби и другие вещи, которые все еще будут видны ps(пока вы будете получать список PID с помощью ps).

Используйте inotifywait для отслеживания некоторых файлов, которые закрываются, когда ваш процесс завершается. Пример (в Linux):

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

-e указывает ожидаемое событие, -q означает минимальный вывод только после завершения. В этом случае это будет:

logfile.log CLOSE_WRITE,CLOSE

Одну команду ожидания можно использовать для ожидания нескольких процессов:

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

Выходная строка inotifywait сообщит вам, какой процесс завершен. Это работает только с «настоящими» файлами, а не с чем-то в / proc /

В такой системе, как OSX, у вас может не быть pgrep, поэтому вы можете попробовать это приложение при поиске процессов по имени:

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

$Символ в конце имени процесса гарантирует , что GREP матчи только process_name до конца строки в выходной пс , а не сам по себе.

Решение Рауно Палосаари для Timeout in Seconds Darwin, является отличным обходным решением для UNIX-подобной ОС, которая не имеет GNU tail(она не является специфической для Darwin). Но, в зависимости от возраста 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это интервал опроса (в секундах), поэтому его можно изменить в соответствии с ситуацией.