Warten Sie, bis ein Vorgang abgeschlossen ist

Gibt es eine integrierte Funktion in Bash, die darauf wartet, dass ein Prozess abgeschlossen ist?

Mit dem waitBefehl kann nur gewartet werden, bis untergeordnete Prozesse abgeschlossen sind. Ich würde gerne wissen, ob es eine Möglichkeit gibt, auf den Abschluss eines Prozesses zu warten, bevor Sie mit einem Skript fortfahren.

Ein mechanischer Weg, dies zu tun, ist wie folgt, aber ich würde gerne wissen, ob es in Bash eine eingebaute Funktion gibt.

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

Warten, bis ein Vorgang abgeschlossen ist

Linux:

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

Darwin (erfordert, dass $pidoffene Dateien hat):

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

Mit Zeitüberschreitung (Sekunden)

Linux:

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

Darwin (erfordert, dass $pidoffene Dateien hat):

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

Es gibt keine eingebauten. Verwendung kill -0in einer Schleife für eine praktikable Lösung:

anywait(){

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

Oder als einfacher Oneliner für die einfache einmalige Verwendung:

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

Wie mehrere Kommentatoren festgestellt haben, haben Sie eine andere Möglichkeit gefunden, um festzustellen, ob der Prozess ausgeführt wird, um den kill -0 $pidAufruf zu ersetzen, wenn Sie auf Prozesse warten möchten, an die Sie keine Berechtigung zum Senden von Signalen haben . Funktioniert unter Linux, test -d "/proc/$pid"auf anderen Systemen, die Sie möglicherweise verwenden müssen pgrep(falls verfügbar) oder ähnliches ps | grep "^$pid ".

Ich habe festgestellt, dass "kill -0" nicht funktioniert, wenn der Prozess root (oder einem anderen) gehört. Deshalb habe ich pgrep verwendet und mir Folgendes ausgedacht:

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

Dies hätte den Nachteil, dass wahrscheinlich Zombie-Prozesse übereinstimmen.

Diese Bash-Skriptschleife endet, wenn der Prozess nicht vorhanden ist oder es sich um einen Zombie handelt.

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

EDIT : Das obige Skript wurde unten von Rockallite gegeben . Vielen Dank!

Meine ursprüngliche Antwort unten funktioniert für Linux und basiert auf procfsdh /proc/. Ich kenne die Portabilität nicht:

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

Es ist nicht auf die Shell beschränkt, aber die Betriebssysteme selbst haben keine Systemaufrufe, um die Beendigung von nicht untergeordneten Prozessen zu überwachen.

FreeBSD und Solaris haben dieses praktische pwait(1)Dienstprogramm, das genau das tut, was Sie wollen.

Ich glaube, andere moderne Betriebssysteme haben auch die erforderlichen Systemaufrufe (MacOS implementiert beispielsweise BSDs kqueue), aber nicht alle stellen sie über die Befehlszeile zur Verfügung.

Aus der Bash-Manpage

   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.

Alle diese Lösungen werden in Ubuntu 14.04 getestet:

Lösung 1 (mit dem Befehl ps): Um die Antwort von Pierz zu addieren, würde ich vorschlagen:

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

grep -vw grepStellt in diesem Fall sicher, dass grep nur mit process_name und nicht mit grep selbst übereinstimmt. Es hat den Vorteil, dass Fälle unterstützt werden, in denen der Prozessname nicht am Ende einer Zeile bei steht ps axg.

Lösung 2 (unter Verwendung des Befehls top und des Prozessnamens):

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

Ersetzen Sie process_namedurch den Prozessnamen, der in angezeigt wird top -n 1 -b. Bitte halten Sie die Anführungszeichen.

Um die Liste der Prozesse anzuzeigen, auf deren Abschluss Sie warten, können Sie Folgendes ausführen:

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

Lösung 3 (unter Verwendung des Befehls top und der Prozess-ID):

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

Ersetzen Sie process_iddurch die Prozess-ID Ihres Programms.

Okay, die Antwort scheint zu sein: Nein, es gibt kein eingebautes Tool.

Nach dem Einstellen /proc/sys/kernel/yama/ptrace_scopeauf 0ist es möglich, das straceProgramm zu verwenden. Weitere Schalter können verwendet werden, um es leise zu machen, so dass es wirklich passiv wartet:

strace -qqe '' -p <PID>

Blockierungslösung

Verwenden Sie die waitin einer Schleife, um darauf zu warten, dass alle Prozesse beendet werden:

function anywait()
{

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

Diese Funktion wird sofort beendet, wenn alle Prozesse beendet wurden. Dies ist die effizienteste Lösung.

Nicht blockierende Lösung

Verwenden Sie die kill -0in einer Schleife, um auf das Beenden aller Prozesse zu warten und zwischen den Überprüfungen etwas zu tun:

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

Die Reaktionszeit verkürzte sich auf die sleepZeit, da eine hohe CPU-Auslastung verhindert werden muss.

Eine realistische Verwendung:

Warten auf das Beenden aller Prozesse + Informieren Sie den Benutzer über alle laufenden PIDs.

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

Anmerkungen

Diese Funktionen erhalten PIDs über Argumente von $@als BASH-Array.

Hatte das gleiche Problem, löste ich das Problem, indem ich den Prozess abbrach und dann darauf wartete, dass jeder Prozess mit dem PROC-Dateisystem beendet wurde:

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

Es gibt keine integrierte Funktion, die darauf warten kann, dass ein Prozess abgeschlossen wird.

Sie können kill -0an jede gefundene PID senden , damit Sie nicht von Zombies und Dingen verwirrt werden, die noch sichtbar sind ps(während Sie die PID-Liste mit abrufen ps).

Verwenden Sie inotifywait, um eine Datei zu überwachen, die geschlossen wird, wenn Ihr Prozess beendet wird. Beispiel (unter Linux):

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

-e gibt das Ereignis an, auf das gewartet werden soll. -q bedeutet minimale Ausgabe nur bei Beendigung. In diesem Fall ist es:

logfile.log CLOSE_WRITE,CLOSE

Mit einem einzigen Wartebefehl können Sie auf mehrere Prozesse warten:

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

Die Ausgabezeichenfolge von inotifywait gibt an, welcher Prozess beendet wurde. Dies funktioniert nur mit 'echten' Dateien, nicht mit etwas in / proc /

Auf einem System wie OSX verfügen Sie möglicherweise nicht über pgrep, sodass Sie diesen Ansatz ausprobieren können, wenn Sie nach Prozessen mit Namen suchen:

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

Das $Symbol am Ende des Prozessnamens stellt sicher, dass grep nur process_name mit dem Zeilenende in der ps-Ausgabe und nicht mit sich selbst übereinstimmt.

Die Lösung von Rauno Palosaari für Timeout in Seconds Darwinist eine hervorragende Problemumgehung für ein UNIX-ähnliches Betriebssystem ohne GNU tail(es ist nicht spezifisch für Darwin). Abhängig vom Alter des UNIX-ähnlichen Betriebssystems ist die angebotene Befehlszeile jedoch komplexer als erforderlich und kann fehlschlagen:

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

Unter mindestens einem alten UNIX schlägt das lsofArgument +r 1m%sfehl (auch für einen Superuser):

lsof: can't read kernel name list.

Dies m%sist eine Ausgabeformatspezifikation. Ein einfacher Postprozessor benötigt es nicht. Der folgende Befehl wartet beispielsweise bis zu fünf Sekunden auf PID 5959:

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

In diesem Beispiel ist, wenn PID 5959 vor Ablauf der fünf Sekunden von selbst beendet ${?}wird 0. Wenn nicht, ${?}kehrt 1nach fünf Sekunden zurück.

Es lohnt sich ausdrücklich sein kann , dass die in der Feststellung +r 1, das 1ist das Abfrageintervall (in Sekunden), so dass es geändert werden kann , um die Situation zu entsprechen.