Poczekaj na zakończenie procesu

Czy jest jakaś wbudowana funkcja w Bash, która ma czekać na zakończenie procesu?

waitKomenda pozwala tylko jeden czekać procesów potomnych, aby zakończyć. Chciałbym wiedzieć, czy istnieje sposób, aby poczekać na zakończenie jakiegokolwiek procesu przed przystąpieniem do jakiegokolwiek skryptu.

Mechaniczny sposób na to jest następujący, ale chciałbym wiedzieć, czy w Bash jest jakaś wbudowana funkcja.

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

Czekać na zakończenie procesu

Linux:

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

Darwin (wymaga, aby $pidmieć otwarte pliki):

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

Z limitem czasu (sekundy)

Linux:

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

Darwin (wymaga, aby $pidmieć otwarte pliki):

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

Nie ma wbudowanej. Użyj kill -0w pętli, aby uzyskać działające rozwiązanie:

anywait(){

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

Lub jako prostszy oneliner do łatwego jednorazowego użycia:

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

Jak zauważyło kilku komentatorów, jeśli chcesz czekać na procesy, do których nie masz uprawnień do wysyłania sygnałów, musisz znaleźć inny sposób na wykrycie, czy proces jest uruchomiony, aby zastąpić kill -0 $pidwywołanie. W systemie Linux test -d "/proc/$pid"działa, w innych systemach może być konieczne użycie pgrep(jeśli jest dostępny) lub czegoś podobnego ps | grep "^$pid ".

Zauważyłem, że "kill -0" nie działa, jeśli właścicielem procesu jest root (lub inny), więc użyłem pgrep i wymyśliłem:

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

Miałoby to tę wadę, że prawdopodobnie pasowałoby do procesów zombie.

Ta pętla skryptu bash kończy się, jeśli proces nie istnieje lub jest zombie.

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

EDYCJA : Powyższy skrypt został podany poniżej przez Rockallite . Dzięki!

Moja oryginalna odpowiedź poniżej działa dla systemu Linux, polegając na procfs np /proc/. Nie znam jego przenośności:

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

Nie ogranicza się to do powłoki, ale same systemy operacyjne nie mają wywołań systemowych do obserwowania zakończenia procesu innego niż dziecko.

FreeBSD i Solaris mają to przydatne pwait(1) narzędzie, które robi dokładnie to, co chcesz.

Uważam, że inne nowoczesne systemy operacyjne również mają niezbędne wywołania systemowe (na przykład MacOS implementuje BSD kqueue), ale nie wszystkie udostępniają je z wiersza poleceń.

Ze strony podręcznika 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.

Wszystkie te rozwiązania są testowane w Ubuntu 14.04:

Rozwiązanie 1 (za pomocą polecenia ps): Aby dodać do odpowiedzi Pierz, proponuję:

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

W tym przypadku grep -vw grepzapewnia, że ​​grep pasuje tylko do procesu nazwa_procesu, a nie do samego grep. Ma tę zaletę, że obsługuje przypadki, w których nazwa_procesu nie znajduje się na końcu wiersza w ps axg.

Rozwiązanie 2 (używając najwyższego polecenia i nazwy procesu):

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

Zastąp process_namenazwę procesu, która pojawia się w top -n 1 -b. Proszę zachować cudzysłowy.

Aby zobaczyć listę procesów, które czekasz na zakończenie, możesz uruchomić:

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

Rozwiązanie 3 (przy użyciu polecenia górnego i identyfikatora procesu):

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

Zastąp process_ididentyfikatorem procesu swojego programu.

Okay, więc wydaje się, że odpowiedź brzmi - nie, nie ma wbudowanego narzędzia.

Po ustawieniu /proc/sys/kernel/yama/ptrace_scopesię 0, możliwe jest korzystanie z straceprogramu. Można użyć dalszych przełączników, aby wyciszyć go, aby naprawdę czekał pasywnie:

strace -qqe '' -p <PID>

Rozwiązanie blokujące

Użyj waitpętli w celu oczekiwania na zakończenie wszystkich procesów:

function anywait()
{

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

Ta funkcja kończy się natychmiast po zakończeniu wszystkich procesów. To najbardziej wydajne rozwiązanie.

Rozwiązanie nieblokujące

Użyj kill -0pętli w celu oczekiwania na zakończenie wszystkich procesów + rób cokolwiek między sprawdzeniami:

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

Czas reakcji skrócił się do sleepczasu, ponieważ trzeba zapobiegać wysokiemu zużyciu procesora.

Realistyczne użycie:

Oczekiwanie na zakończenie wszystkich procesów + poinformowanie użytkownika o wszystkich działających PIDach.

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

Uwagi

Te funkcje pobierają PIDy za pośrednictwem argumentów $@jako tablica BASH.

Gdy miałem ten sam problem, rozwiązałem go, zabijając proces, a następnie czekając na zakończenie każdego procesu przy użyciu systemu plików PROC:

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

Nie ma wbudowanej funkcji czekającej na zakończenie jakiegokolwiek procesu.

Możesz wysłać kill -0do dowolnego znalezionego PID, więc nie zdziwisz się zombie i rzeczy, które będą nadal widoczne w ps(podczas wciąż pobierania listy PID za pomocą ps).

Użyj inotifywait, aby monitorować jakiś plik, który zostaje zamknięty po zakończeniu procesu. Przykład (w systemie Linux):

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

-e określa zdarzenie, na które należy czekać, -q oznacza minimalne wyjście tylko po zakończeniu. W tym przypadku będzie to:

logfile.log CLOSE_WRITE,CLOSE

Do oczekiwania na wiele procesów można użyć jednego polecenia oczekiwania:

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

Wynikowy ciąg inotifywait powie ci, który proces został zakończony. Działa to tylko z „prawdziwymi” plikami, a nie z czymś w / proc /

W systemie takim jak OSX możesz nie mieć pgrep, więc możesz wypróbować tę metodę, szukając procesów według nazwy:

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

$Symbol na końcu nazwy, zapewnia, że proces grep mecze process_name tylko do końca linii w wyjściu ps a nie sama.

Rozwiązanie Rauno Palosaari dla Timeout in Seconds Darwin, jest doskonałym obejściem dla systemu operacyjnego podobnego do UNIX, który nie ma GNU tail(nie jest specyficzny dla Darwin). Jednak w zależności od wieku systemu operacyjnego podobnego do UNIX, oferowany wiersz poleceń jest bardziej złożony niż to konieczne i może zawieść:

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

Na co najmniej jednym starym UNIXie lsofargument +r 1m%szawodzi (nawet dla superużytkownika):

lsof: can't read kernel name list.

m%sJest specyfikacja formatu wyjściowego. Prostszy postprocesor tego nie wymaga. Na przykład następujące polecenie czeka na PID 5959 przez maksymalnie pięć sekund:

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

W tym przykładzie, jeśli PID 5959 kończy się samoistnie przed upływem pięciu sekund, ${?}to jest 0. Jeśli nie ${?}wraca1 po pięciu sekundach.

Warto wyraźnie zauważyć, że w +r 1programie 1jest interwał odpytywania (w sekundach), więc można go zmienić w zależności od sytuacji.