Erhalte den Exit-Code eines Hintergrundprozesses

1: In der bash, $! hält die PID des letzten hintergrund-Prozess ausgeführt wurde. Das wird Ihnen sagen, welche Prozesse zu überwachen, sowieso.

4: wait <n> wartet, bis der Prozess mit der ID abgeschlossen ist (es wird blockiert, bis der Prozess abgeschlossen ist, so dass Sie vielleicht nicht wollen, rufen Sie diese, bis Sie sicher sind, dass der Prozess abgeschlossen ist). Nach wait gibt, ist der exit-code des Prozesses wird wieder in die variable $?

2, 3: ps oder ps | grep " $! " kann Ihnen sagen, ob der Prozess noch läuft. Es ist bis zu Ihnen, wie zu verstehen, die Ausgabe und entscheiden, wie nahe es ist, zu schlichten. (ps | grep ist nicht idiotensicher. Wenn Sie Zeit haben, können Sie kommen mit einer robusten Weise zu sagen, ob der Prozess noch läuft).

Hier ist ein skeleton-script:

# simulate a long process that will have an identifiable exit code
(sleep 15 ; /bin/false) &
my_pid=$!

while   ps | grep " $my_pid "     # might also need  | grep -v grep  here
do
    echo $my_pid is still in the ps output. Must still be running.
    sleep 3
done

echo Oh, it looks like the process is done.
wait $my_pid
my_status=$?
echo The exit status of the process was $my_status

InformationsquelleAutor der Antwort mob

Wie ich das sehe, fast alle Antworten, die Verwendung externer Dienstprogramme (meist ps) zu poll den Stand der Prozess im hintergrund. Es ist ein mehr unixesh Lösung, fangen die SIGCHLD-signal. In der signal-handler muss überprüft werden, welcher child-Prozess beendet wurde. Es kann getan werden, indem kill -0 <PID> eingebaut (universal) oder die überprüfung der Existenz von /proc/<PID> - Verzeichnis (Linux-spezifisch) oder mit der jobs eingebaut (bash spezifische. jobs -l berichtet auch die pid. In diesem Fall ist das 3. Feld der Ausgang Gestoppt werden kann|Running|Done|Beenden . ).

Hier ist mein Beispiel.

Startete der Prozess heißt loop.sh. Es akzeptiert -x oder eine Zahl als argument. Für -x ist beendet mit exit-code 1. Für eine Nummer es wartet num*5 Sekunden. In alle 5 Sekunden druckt er seine PID.

Der launcher-Prozess aufgerufen wird launch.sh:

#!/bin/bash

handle_chld() {
    local tmp=()
    for((i=0;i<${#pids[@]};++i)); do
        if [ ! -d /proc/${pids[i]} ]; then
            wait ${pids[i]}
            echo "Stopped ${pids[i]}; exit code: $?"
        else tmp+=(${pids[i]})
        fi
    done
    pids=(${tmp[@]})
}

set -o monitor
trap "handle_chld" CHLD

# Start background processes
./loop.sh 3 &
pids+=($!)
./loop.sh 2 &
pids+=($!)
./loop.sh -x &
pids+=($!)

# Wait until all background processes are stopped
while [ ${#pids[@]} -gt 0 ]; do echo "WAITING FOR: ${pids[@]}"; sleep 2; done
echo STOPPED

Weitere Erklärung siehe: Starten Sie einen Prozess von der bash-Skript fehlgeschlagen

InformationsquelleAutor der Antwort TrueY

Ich würde ändern Sie Ihr Ansatz etwas. Eher als die überprüfung alle paar Sekunden, wenn der Befehl noch aktiv ist, und die Berichterstattung eine Nachricht, haben, einem anderen Prozess, dass die Berichte alle paar Sekunden, die der Befehl wird noch ausgeführt und dann töten Sie diesen Prozess, wenn der Befehl abgeschlossen ist. Zum Beispiel:

#!/bin/sh 

cmd() { sleep 5; exit 24; } 

cmd & # Ausführen des lange Laufenden Prozess 
pid=$! # Record pid 

# Spawn ein Prozess, der coninually meldet, dass der Befehl noch läuft 
während echo "$(date): $pid noch läuft"; do sleep 1; done & 
echoer=$! 

# Eine Falle zu töten die reporter, wenn der Prozess abgeschlossen ist 
trap 'kill $echoer' 0 

# Warten Sie, bis der Prozess abgeschlossen ist 
wenn wait $pid; dann 
echo "cmd gelungen" 
sonst 
echo "cmd FAILED!! (zurückgegeben $?)" 
fi 

InformationsquelleAutor der Antwort William Pursell

Unser team hatte das gleiche muss mit einem remote-SSH-Skript ausgeführt, das timing war nach 25 Minuten Inaktivität. Hier ist eine Lösung mit der monitoring-Schleife die überprüfung der Prozess im hintergrund jede Sekunde, aber drucken nur alle 10 Minuten zu unterdrücken, um eine Inaktivitäts-timeout.

long_running.sh & 
pid=$!

# Wait on a background job completion. Query status every 10 minutes.
declare -i elapsed=0
# `ps -p ${pid}` works on macOS and CentOS. On both OSes `ps ${pid}` works as well.
while ps -p ${pid} >/dev/null; do
  sleep 1
  if ((++elapsed % 600 == 0)); then
    echo "Waiting for the completion of the main script. $((elapsed /60))m and counting ..."
  fi
done

# Return the exit code of the terminated background process. This works in Bash 4.4 despite what Bash docs say:
# "If neither jobspec nor pid specifies an active child process of the shell, the return status is 127."
wait ${pid}

InformationsquelleAutor der Antwort DKroot

Andere Lösung ist es, Prozesse überwachen, über das proc-Dateisystem (sicherer als ps/grep-combo); wenn Sie einen Prozess starten, hat es einen entsprechenden Ordner in /proc/$pid, also die Lösung könnte sein,

#!/bin/bash
....
doSomething &
local pid=$!
while [ -d /proc/$pid ]; do # While directory exists, the process is running
    doSomethingElse
    ....
else # when directory is removed from /proc, process has ended
    wait $pid
    local exit_status=$?
done
....

Jetzt können Sie die $exit_status variable, wie du willst.

InformationsquelleAutor der Antwort Искрен Хаджинедев

Mit dieser Methode, wird Ihr script nicht warten, bis der Prozess im hintergrund, Sie wird nur zu überwachen, eine temporäre Datei, die den exit-status.

FUNCmyCmd() { sleep 3;return 6; };

export retFile=$(mktemp); 
FUNCexecAndWait() { FUNCmyCmd;echo $? >$retFile; }; 
FUNCexecAndWait&

nun, Ihr Skript etwas anderes tun können, während Sie einfach nur zu halten, die überwachung der Inhalte von retFile (es können auch andere Informationen, die Sie wollen, wie die exit time).

PS.: btw, ich kodierte denken in der bash

InformationsquelleAutor der Antwort Aquarius Power