Bir işlemin bitmesini bekleyin

Bash'te bir sürecin bitmesini bekleyecek yerleşik bir özellik var mı?

waitKomutu tek bitirmek için çocuk süreçleri için beklemek sağlar. Herhangi bir komut dosyasında devam etmeden önce herhangi bir işlemin bitmesini beklemenin herhangi bir yolu olup olmadığını bilmek istiyorum.

Bunu yapmanın mekanik bir yolu aşağıdaki gibidir, ancak Bash'te herhangi bir yerleşik özellik olup olmadığını bilmek istiyorum.

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

Herhangi bir işlemin bitmesini beklemek için

Linux:

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

Darwin ( $pidaçık dosyaları olmasını gerektirir ):

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

Zaman aşımı ile (saniye)

Linux:

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

Darwin ( $pidaçık dosyaları olmasını gerektirir ):

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

Yerleşik yok. kill -0Uygulanabilir bir çözüm için bir döngüde kullanın :

anywait(){

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

Veya tek seferlik kolay kullanım için daha basit bir oneliner olarak:

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

Birkaç yorumcunun belirttiği gibi, sinyal gönderme izniniz olmayan süreçleri beklemek istiyorsanız, kill -0 $pidçağrıyı değiştirmek için sürecin çalışıp çalışmadığını tespit etmenin başka bir yolunu bulursunuz . Linux'ta test -d "/proc/$pid"çalışır, diğer sistemlerde pgrep(varsa) veya benzeri bir şey kullanmanız gerekebilir ps | grep "^$pid ".

Süreç kök (veya başka) aitse "kill -0" işe yaramaz buldum, bu yüzden pgrep kullandım ve ile geldi:

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

Bu muhtemelen zombi süreçlerini eşleştirme dezavantajına sahip olacaktır.

Bu bash komut dosyası döngüsü, işlem yoksa veya bir zombi olduğunda sona erer.

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

EDIT : Yukarıdaki komut dosyası aşağıda Rockallite tarafından verilmiştir . Teşekkürler!

Aşağıdaki orijinal cevabım, procfsyani Linux için çalışıyor /proc/. Taşınabilirliğini bilmiyorum:

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

Kabuk ile sınırlı değildir, ancak işletim sisteminin kendilerinin çocuk olmayan süreç sonlandırmasını izlemek için sistem çağrıları yoktur.

FreeBSD ve Solaris pwait(1), tam olarak ne istediğinizi yapan bu kullanışlı yardımcı programa sahiptir.

Diğer modern işletim sistemlerinin de gerekli sistem çağrılarına sahip olduğuna inanıyorum (örneğin, MacOS, BSD'leri uygular kqueue), ancak hepsini komut satırından kullanılabilir hale getirmez.

Bash Manpage'den

   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.

Tüm bu çözümler Ubuntu 14.04'te test edilmiştir:

Çözüm 1 (ps komutunu kullanarak): Sadece Pierz cevabına eklemek için şunu öneririm:

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

Bu durumda, grep -vw grepgrep'in grep'in kendisiyle değil, yalnızca process_name ile eşleşmesini sağlar. Process_name öğesinin bir satırın sonunda olmadığı durumları destekleme avantajına sahiptir ps axg.

Çözüm 2 (top komutunu ve işlem adını kullanarak):

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

process_nameGörünen işlem adıyla değiştirin top -n 1 -b. Lütfen tırnak işaretlerini saklayın.

Tamamlanmasını beklediğiniz işlemlerin listesini görmek için şunları çalıştırabilirsiniz:

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

Çözüm 3 (top komutunu ve işlem kimliğini kullanarak):

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

process_idProgramınızın işlem kimliğiyle değiştirin .

Tamam, öyle görünüyor ki cevap - hayır, yerleşik bir araç yok.

Ayarladıktan sonra /proc/sys/kernel/yama/ptrace_scopeiçin 0, kullanmak mümkündür straceprogramı. Sessiz hale getirmek için daha fazla anahtar kullanılabilir, böylece pasif olarak bekler:

strace -qqe '' -p <PID>

Engelleme çözümü

waitTüm işlemleri sonlandırmayı beklemek için bir döngü içinde kullanın :

function anywait()
{

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

Bu işlev, tüm işlemler sonlandırıldığında hemen çıkacaktır. Bu en verimli çözümdür.

Tıkanmasız çözüm

kill -0Tüm işlemleri sonlandırmak + kontroller arasında herhangi bir şey yapmak için döngü içinde kullanın :

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

sleepYüksek CPU kullanımını önlemek zorunda olduğu için reaksiyon süresi zamanla azaldı .

Gerçekçi bir kullanım:

Tüm işlemleri sonlandırmayı beklemek + çalışan tüm PID'ler hakkında kullanıcıyı bilgilendirmek .

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

notlar

Bu işlevler, $@ , BASH dizisi olarak .

Aynı sorun vardı, süreci öldürme ve daha sonra her sürecin PROC dosya sistemini kullanarak bitmesini beklerken sorunu çözdüm:

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

Herhangi bir işlemin bitmesini bekleyecek yerleşik bir özellik yoktur.

kill -0Bulunan herhangi bir PID'ye gönderebilirsiniz , böylece zombiler ve hala görünür olacak şeyler tarafından şaşkın olmazsınız ps(yine de kullanarak PID listesini alırken ps).

İşleminiz sona erdiğinde kapatılan bazı dosyaları izlemek için inotifywait kullanın. Örnek (Linux'ta):

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

-e beklenecek olayı belirtir, -q sadece sonlandırmada minimum çıktı anlamına gelir. Bu durumda:

logfile.log CLOSE_WRITE,CLOSE

Birden çok işlemi beklemek için tek bir bekleme komutu kullanılabilir:

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

İnotifywait çıktı dizesi size hangi işlemin sonlandığını söyleyecektir. Bu yalnızca 'gerçek' dosyalarla çalışır, / proc /

OSX gibi bir sistemde pgrep olmayabilir, böylece isimleri isme göre ararken bu değerlendirmeyi deneyebilirsiniz:

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

$Süreç adı aktarımı sağlar sonundaki sembol grep eşleşmeleri sadece ps çıktısında satırın sonuna olup kendisine Process_Name söyledi.

Rauno Palosaari'nin çözümü Timeout in Seconds Darwin, GNU'su olmayan UNIX benzeri bir işletim sistemi için mükemmel bir çözümdür tail(spesifik değildir Darwin). Ancak, UNIX benzeri işletim sisteminin yaşına bağlı olarak, sunulan komut satırı gerektiğinden daha karmaşıktır ve başarısız olabilir:

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

En az bir eski UNIX'te, lsofargüman +r 1m%sbaşarısız olur (bir süper kullanıcı için bile):

lsof: can't read kernel name list.

Bu m%sbir çıktı biçimi belirtimidir. Daha basit bir son işlemci gerektirmez. Örneğin, aşağıdaki komut PID 5959'da beş saniyeye kadar bekler:

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

Bu örnekte, PID 5959 beş saniye geçmeden kendi isteğinden çıkarsa, ${?}olur 0. Değilse beş saniye sonra ${?}geri döner 1.

Bu açıkça bu in'i dikkati olabilir +r 1, 1duruma uygun şekilde değiştirilebilir, böylece (saniye) anket aralığıdır.