Espera a que termine un proceso

¿Hay alguna función integrada en Bash para esperar a que finalice un proceso?

El waitcomando solo permite esperar a que finalicen los procesos secundarios. Me gustaría saber si hay alguna forma de esperar a que termine algún proceso antes de continuar con cualquier script.

Una forma mecánica de hacer esto es la siguiente, pero me gustaría saber si hay alguna característica integrada en Bash.

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

Esperar a que termine cualquier proceso

Linux:

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

Darwin (requiere que $pidtenga archivos abiertos):

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

Con tiempo de espera (segundos)

Linux:

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

Darwin (requiere que $pidtenga archivos abiertos):

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

No hay incorporado. Use kill -0en un bucle para una solución viable:

anywait(){

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

O como una línea más simple para un uso fácil y único:

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

Como señalaron varios comentaristas, si desea esperar procesos a los que no tiene el privilegio de enviar señales, debe encontrar otra forma de detectar si el proceso se está ejecutando para reemplazar la kill -0 $pidllamada. En Linux, test -d "/proc/$pid"funciona, en otros sistemas puede que tenga que usar pgrep(si está disponible) o algo así ps | grep "^$pid ".

Encontré que "kill -0" no funciona si el proceso es propiedad de root (u otro), así que usé pgrep y se me ocurrió:

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

Esto tendría la desventaja de que probablemente coincida con los procesos de zombies.

Este bucle de script bash finaliza si el proceso no existe o si es un zombie.

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

EDITAR : El guión anterior fue dado a continuación por Rockallite . ¡Gracias!

Mi respuesta original a continuación funciona para Linux, confiando en procfsie /proc/. No sé su portabilidad:

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

No se limita al shell, pero los sistemas operativos en sí no tienen llamadas al sistema para ver la finalización del proceso que no es secundario.

FreeBSD y Solaris tienen esta práctica pwait(1)utilidad, que hace exactamente lo que quieres.

Creo que otros sistemas operativos modernos también tienen las llamadas necesarias al sistema (MacOS, por ejemplo, implementa BSD kqueue), pero no todos lo hacen disponible desde la línea de comandos.

Desde la página de manual de 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.

Todas estas soluciones se prueban en Ubuntu 14.04:

Solución 1 (usando el comando ps): solo para agregar a la respuesta de Pierz, sugeriría:

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

En este caso, grep -vw grepasegura que grep solo coincida con nombre_proceso y no grep en sí mismo. Tiene la ventaja de admitir los casos en que process_name no está al final de una línea en ps axg.

Solución 2 (usando el comando superior y el nombre del proceso):

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

Reemplace process_namecon el nombre del proceso que aparece en top -n 1 -b. Por favor, mantenga las comillas.

Para ver la lista de procesos que espera a que finalicen, puede ejecutar:

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

Solución 3 (usando el comando superior y la ID del proceso):

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

Reemplace process_idcon el ID de proceso de su programa.

De acuerdo, parece que la respuesta es: no, no hay una herramienta integrada.

Después de ajustar /proc/sys/kernel/yama/ptrace_scopea 0, es posible utilizar el straceprograma. Se pueden usar más interruptores para silenciarlo, de modo que realmente espere pasivamente:

strace -qqe '' -p <PID>

Solución de bloqueo

Use el waiten un bucle para esperar a que finalicen todos los procesos:

function anywait()
{

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

Esta función se cerrará de inmediato, cuando todos los procesos se terminaron. Esta es la solución más eficiente.

Solución no bloqueante

Utilice el kill -0en un bucle, para esperar la finalización de todos los procesos + hacer cualquier cosa entre comprobaciones:

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

El tiempo de reacción disminuyó a sleeptiempo, ya que hay que evitar el uso elevado de CPU.

Un uso realista:

En espera de terminar todos los procesos + informar al usuario sobre todos los PID en ejecución.

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

Notas

Estas funciones obtienen PID a través de argumentos $@como BASH array.

Tuve el mismo problema, resolví el problema eliminando el proceso y luego esperando que cada proceso terminara de usar el sistema de archivos PROC:

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

No hay una función integrada que espere a que finalice cualquier proceso.

Podrías enviar kill -0a cualquier PID encontrado, para que no te desconcierten los zombis y las cosas que aún serán visibles ps(mientras recuperas la lista PID usando ps).

Use inotifywait para monitorear algunos archivos que se cierran cuando finaliza su proceso. Ejemplo (en Linux):

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

-e especifica el evento a esperar, -q significa salida mínima solo en la terminación. En este caso será:

logfile.log CLOSE_WRITE,CLOSE

Se puede usar un solo comando de espera para esperar múltiples procesos:

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

La cadena de salida de inotifywait le dirá qué proceso finalizó. Esto solo funciona con archivos 'reales', no con algo en / proc /

En un sistema como OSX, es posible que no tenga pgrep, por lo que puede probar esta aproximación cuando busque procesos por nombre:

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

El $símbolo al final del nombre del proceso garantiza que grep solo coincida con nombre_proceso al final de la línea en la salida ps y no a sí mismo.

La solución de Rauno Palosaari Timeout in Seconds Darwines una excelente solución para un sistema operativo tipo UNIX que no tiene GNU tail(no es específico para Darwin). Pero, dependiendo de la antigüedad del sistema operativo tipo UNIX, la línea de comandos que se ofrece es más compleja de lo necesario y puede fallar:

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

En al menos un UNIX antiguo, el lsofargumento +r 1m%sfalla (incluso para un superusuario):

lsof: can't read kernel name list.

El m%ses una especificación de formato de salida. Un postprocesador más simple no lo requiere. Por ejemplo, el siguiente comando espera en PID 5959 hasta cinco segundos:

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

En este ejemplo, si el PID 5959 sale por sí solo antes de que transcurran los cinco segundos, ${?}es 0. Si no ${?}regresa1 después de cinco segundos.

Vale la pena señalar expresamente que en +r 1, 1es el intervalo de sondeo (en segundos), por lo que puede cambiarse para adaptarse a la situación.