Aguarde a conclusão de um processo

Existe algum recurso interno no Bash para aguardar a conclusão de um processo?

O waitcomando permite apenas aguardar a conclusão dos processos filhos. Gostaria de saber se há alguma maneira de aguardar a conclusão de qualquer processo antes de prosseguir em qualquer script.

Uma maneira mecânica de fazer isso é a seguinte, mas eu gostaria de saber se existe algum recurso interno no Bash.

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

Para aguardar a conclusão de qualquer processo

Linux:

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

Darwin (requer que $pidtenha arquivos abertos):

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

Com tempo limite (segundos)

Linux:

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

Darwin (requer que $pidtenha arquivos abertos):

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

Não há embutido. Use kill -0em loop para uma solução viável:

anywait(){

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

Ou como um oneliner mais simples para facilitar o uso único:

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

Conforme observado por vários comentaristas, se você deseja aguardar processos para os quais não tem o privilégio de enviar sinais, há outra maneira de detectar se o processo está sendo executado para substituir a kill -0 $pidchamada. No Linux, test -d "/proc/$pid"funciona, em outros sistemas que você pode precisar usar pgrep(se disponível) ou algo parecido ps | grep "^$pid ".

Eu descobri que "kill -0" não funciona se o processo é de propriedade do root (ou outro), então usei o pgrep e criei:

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

Isso teria a desvantagem de provavelmente corresponder aos processos zumbis.

Esse loop do script bash termina se o processo não existir ou se for um zumbi.

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

EDIT : O script acima foi dado abaixo pela Rockallite . Obrigado!

Minha resposta original abaixo funciona para Linux, contando com procfsie /proc/. Não conheço sua portabilidade:

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

Não se limita ao shell, mas os SOs não têm chamadas de sistema para assistir ao encerramento de processos não-filhos.

O FreeBSD e o Solaris possuem esse pwait(1)utilitário útil , que faz exatamente o que você deseja.

Acredito que outros sistemas operacionais modernos também tenham as chamadas de sistema necessárias (o MacOS, por exemplo, implementa o BSD kqueue), mas nem todos o disponibilizam na linha de comando.

Na página de manual do 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 essas soluções são testadas no Ubuntu 14.04:

Solução 1 (usando o comando ps): Apenas para adicionar a resposta de Pierz, sugiro:

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

Nesse caso, grep -vw grepgarante que o grep corresponda apenas ao process_name e não ao próprio grep. Tem a vantagem de suportar os casos em que o process_name não está no final de uma linha em ps axg.

Solução 2 (usando o comando top e o nome do processo):

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

Substitua process_namepelo nome do processo que aparece em top -n 1 -b. Por favor, mantenha as aspas.

Para ver a lista de processos que você espera que sejam concluídos, você pode executar:

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

Solução 3 (usando o comando superior e o ID do processo):

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

Substitua process_idpelo ID do processo do seu programa.

Ok, parece que a resposta é - não, não existe uma ferramenta integrada.

Depois de definir /proc/sys/kernel/yama/ptrace_scopepara 0, é possível usar o straceprograma. Outros comutadores podem ser usados ​​para silenciá-lo, para que ele realmente espere passivamente:

strace -qqe '' -p <PID>

Solução de bloqueio

Use o waitem um loop, para aguardar o término de todos os processos:

function anywait()
{

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

Esta função sai imediatamente, quando todos os processos foram finalizados. Esta é a solução mais eficiente.

Solução sem bloqueio

Use o kill -0loop, para aguardar o término de todos os processos + faça qualquer coisa entre as verificações:

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

O tempo de reação diminuiu para o sleeptempo, porque é necessário impedir o alto uso da CPU.

Um uso realista:

Aguardando o término de todos os processos + informe o usuário sobre todos os PIDs em execução.

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

Essas funções obtêm PIDs por meio de argumentos $@como array BASH.

Teve o mesmo problema, resolvi o problema encerrando o processo e aguardando a conclusão de cada processo usando o sistema de arquivos PROC:

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

Não há recurso interno para aguardar a conclusão de qualquer processo.

Você pode enviar kill -0para qualquer PID encontrado, para não ficar intrigado com zumbis e outras coisas que ainda estarão visíveis ps(enquanto ainda recupera a lista de PIDs ps).

Use inotifywait para monitorar algum arquivo que é fechado quando o processo terminar. Exemplo (no Linux):

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

-e especifica o evento a aguardar, -q significa saída mínima apenas na finalização. Nesse caso, será:

logfile.log CLOSE_WRITE,CLOSE

Um único comando de espera pode ser usado para aguardar vários processos:

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

A sequência de saída do inotifywait informará qual processo foi finalizado. Isso funciona apenas com arquivos 'reais', não com algo em / proc /

Em um sistema como o OSX, você pode não ter o pgrep para tentar esta abordagem ao procurar processos pelo nome:

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

O $símbolo no final do nome do processo garante que o grep corresponda apenas ao process_name ao final da linha na saída ps e não a si próprio.

A solução de Rauno Palosaari para Timeout in Seconds Darwin, é uma excelente solução alternativa para um sistema operacional semelhante ao UNIX que não possui GNU tail(não é específico a Darwin). Mas, dependendo da idade do sistema operacional do tipo UNIX, a linha de comando oferecida é mais complexa do que o necessário e pode falhar:

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

Em pelo menos um UNIX antigo, o lsofargumento +r 1m%sfalha (mesmo para um superusuário):

lsof: can't read kernel name list.

O m%sé uma especificação de formato de saída. Um pós-processador mais simples não exige isso. Por exemplo, o seguinte comando aguarda no PID 5959 por até cinco segundos:

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

Neste exemplo, se o PID 5959 sair por conta própria antes dos cinco segundos decorridos, ${?}será 0. Se não ${?}retornar 1após cinco segundos.

Pode-se notar expressamente que em +r 1, o 1é o intervalo da pesquisa (em segundos), portanto, ele pode ser alterado para se adequar à situação.