Đợi một quá trình kết thúc

Có tính năng dựng sẵn nào trong Bash để chờ quá trình kết thúc không?

Các waitlệnh chỉ cho phép một để chờ tiến trình con đến cuối. Tôi muốn biết liệu có cách nào để chờ bất kỳ quá trình nào kết thúc hay không trước khi tiếp tục bất kỳ kịch bản nào.

Một cách cơ học để làm điều này là như sau nhưng tôi muốn biết liệu có tính năng dựng sẵn nào trong Bash không.

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

Chờ đợi cho bất kỳ quá trình để kết thúc

Linux:

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

Darwin (yêu cầu $pidcó tệp mở):

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

Với thời gian chờ (giây)

Linux:

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

Darwin (yêu cầu $pidcó tệp mở):

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

Không có nội dung nào. Sử dụng kill -0trong một vòng lặp cho một giải pháp khả thi:

anywait(){

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

Hoặc như một oneliner đơn giản hơn để sử dụng một lần dễ dàng:

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

Theo ghi nhận của một số nhà bình luận, nếu bạn muốn đợi các quy trình mà bạn không có đặc quyền gửi tín hiệu đến, bạn đã tìm một số cách khác để phát hiện nếu quy trình đang chạy để thay thế kill -0 $pidcuộc gọi. Trên Linux, test -d "/proc/$pid"hoạt động, trên các hệ thống khác mà bạn có thể phải sử dụng pgrep(nếu có) hoặc đại loại như thế ps | grep "^$pid ".

Tôi thấy "kill -0" không hoạt động nếu tiến trình được sở hữu bởi root (hoặc khác), vì vậy tôi đã sử dụng pgrep và đưa ra:

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

Điều này sẽ có nhược điểm là có thể phù hợp với quá trình zombie.

Vòng lặp bash script này kết thúc nếu quá trình không tồn tại hoặc đó là zombie.

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

EDIT : Kịch bản trên được đưa ra dưới đây bởi Rockallite . Cảm ơn!

Câu trả lời gốc của tôi dưới đây hoạt động cho Linux, dựa vào procfstức là /proc/. Tôi không biết tính di động của nó:

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

Nó không giới hạn ở shell, nhưng bản thân OS không có lệnh gọi hệ thống để xem kết thúc quá trình không phải là con.

FreeBSD và Solaris có tiện dụng này pwait(1) ích , chính xác, những gì bạn muốn.

Tôi tin rằng, các hệ điều hành hiện đại khác cũng có các lệnh gọi hệ thống cần thiết (ví dụ MacOS, thực hiện BSD kqueue), nhưng không phải tất cả đều có sẵn từ dòng lệnh.

Từ trang 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.

Tất cả các giải pháp này đều được thử nghiệm trong Ubuntu 14.04:

Giải pháp 1 (bằng cách sử dụng lệnh ps): Chỉ cần thêm vào câu trả lời của Pierz, tôi sẽ đề xuất:

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

Trong trường hợp này, grep -vw grepđảm bảo rằng grep chỉ khớp với process_name và không phải chính grep. Nó có lợi thế là hỗ trợ các trường hợp trong đó process_name không ở cuối dòng tại ps axg.

Giải pháp 2 (bằng cách sử dụng lệnh trên và tên quy trình):

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

Thay thế process_name bằng tên quy trình xuất hiện trongtop -n 1 -b . Hãy giữ dấu ngoặc kép.

Để xem danh sách các quy trình mà bạn chờ đợi chúng kết thúc, bạn có thể chạy:

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

Giải pháp 3 (bằng cách sử dụng lệnh trên và ID tiến trình):

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

Thay thế process_idbằng ID tiến trình của chương trình của bạn.

Được rồi, có vẻ như câu trả lời là - không, không có công cụ tích hợp.

Sau khi thiết lập /proc/sys/kernel/yama/ptrace_scopeđể 0, người ta có thể sử dụng stracechương trình. Các công tắc tiếp theo có thể được sử dụng để làm cho nó im lặng, để nó thực sự chờ đợi một cách thụ động:

strace -qqe '' -p <PID>

Giải pháp chặn

Sử dụng waitvòng lặp để chờ kết thúc tất cả các quy trình:

function anywait()
{

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

Chức năng này sẽ thoát ngay lập tức, khi tất cả các quy trình đã được chấm dứt. Đây là giải pháp hiệu quả nhất.

Giải pháp không chặn

Sử dụng kill -0trong một vòng lặp, để chờ kết thúc tất cả các quy trình + làm bất cứ điều gì giữa các kiểm tra:

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

Thời gian phản ứng giảm theo sleepthời gian, vì phải ngăn chặn việc sử dụng CPU cao.

Một cách sử dụng thực tế:

Chờ kết thúc tất cả các quy trình + thông báo cho người dùng về tất cả các PID đang chạy.

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

Ghi chú

Các hàm này nhận được các PID thông qua các đối số bằng $@mảng BASH.

Có cùng một vấn đề, tôi đã giải quyết vấn đề giết quá trình và sau đó chờ cho mỗi quá trình kết thúc bằng hệ thống tệp PROC:

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

Không có tính năng dựng sẵn để chờ bất kỳ quá trình nào kết thúc.

Bạn có thể gửi kill -0tới bất kỳ PID nào được tìm thấy, vì vậy bạn không bị bối rối bởi zombie và những thứ vẫn sẽ hiển thị ps(trong khi vẫn truy xuất danh sách PID bằng cách sử dụng ps).

Sử dụng inotifywait để theo dõi một số tệp bị đóng, khi quá trình của bạn kết thúc. Ví dụ (trên Linux):

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

-e chỉ định sự kiện phải chờ, -q có nghĩa là đầu ra tối thiểu chỉ khi kết thúc. Trong trường hợp này, nó sẽ là:

logfile.log CLOSE_WRITE,CLOSE

Một lệnh chờ duy nhất có thể được sử dụng để chờ nhiều quá trình:

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

Chuỗi đầu ra của inotifywait sẽ cho bạn biết, quá trình nào đã kết thúc. Điều này chỉ hoạt động với các tệp 'thực', không hoạt động với / Proc /

Trên một hệ thống như OSX, bạn có thể không có pgrep, vì vậy bạn có thể dùng thử thẩm định này, khi tìm kiếm các quy trình theo tên:

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

Các $biểu tượng ở phần cuối của tên này để thỏa mãn quá trình trận đấu grep chỉ process_name đến cuối dòng trong ps đầu ra và bản thân nó không.

Giải pháp của Rauno Palosaari cho Timeout in Seconds Darwin, là một giải pháp tuyệt vời cho một hệ điều hành giống như UNIX không có GNU tail(nó không dành riêng cho Darwin). Nhưng, tùy thuộc vào độ tuổi của hệ điều hành giống UNIX, dòng lệnh được cung cấp phức tạp hơn mức cần thiết và có thể thất bại:

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

Trên ít nhất một UNIX cũ, lsofđối số +r 1m%skhông thành công (ngay cả đối với siêu người dùng):

lsof: can't read kernel name list.

Đây m%slà một đặc điểm kỹ thuật định dạng đầu ra. Một bộ xử lý hậu đơn giản hơn không yêu cầu nó. Ví dụ: lệnh sau đợi trên PID 5959 trong tối đa năm giây:

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

Trong ví dụ này, nếu PID 5959 thoát ra theo ý mình trước khi hết năm giây, ${?}là 0. Nếu không ${?}trả lại1 sau năm giây.

Có thể đáng lưu ý rằng trong +r 1, 1khoảng thời gian thăm dò ý kiến ​​(tính bằng giây), vì vậy nó có thể được thay đổi cho phù hợp với tình huống.