Bash งานเบื้องหลังและการรันขนาน (job control)



สคริปต์ที่ต้องรอ 5 งานที่ใช้เวลาอย่างละ 1 นาที ไม่จำเป็นต้องใช้ 5 นาที — รันขนานกันเสร็จใน 1 นาที บทนี้ว่าด้วยการรันงานเบื้องหลังและประสานงานให้ถูกต้อง

& — รันเบื้องหลัง

long_task &                      # รันแล้ว prompt กลับมาทันที
echo "เริ่มงาน PID=$!"           # $! = PID ของงานเบื้องหลังล่าสุด

# ทำอย่างอื่นต่อ...

wait                             # รอทุกงานเบื้องหลังจบ
echo "ทุกงานเสร็จ"

& สั่งให้คำสั่งรันใน subshell เบื้องหลัง shell ไม่รอ

jobs, fg, bg (ส่วนใหญ่ใช้ interactive)

sleep 100 &
sleep 200 &
jobs                             # ดูงานเบื้องหลัง
[1]-  Running    sleep 100 &
[2]+  Running    sleep 200 &
fg %1                            # ดึงงาน 1 กลับมา foreground
# Ctrl+Z                         # หยุดงาน foreground ชั่วคราว → กลับเป็น stopped job
bg %1                            # ให้ stopped job รันต่อในเบื้องหลัง
kill %2                          # ฆ่างาน 2

ในสคริปต์ (non-interactive) job control ปิดโดยปริยาย — ใช้ & + $! + wait เป็นหลัก

wait — รอให้จบ

task_a &
pid_a=$!
task_b &
pid_b=$!

wait "$pid_a"; echo "A จบด้วย status $?"
wait "$pid_b"; echo "B จบด้วย status $?"

wait                             # ไม่ระบุ PID = รอทุกงาน

wait $pid คืน exit status ของงานนั้น — วิธีเดียวที่จะรู้ว่างานเบื้องหลังสำเร็จหรือไม่

รันขนานแล้วเก็บผลทุกตัว

#!/usr/bin/env bash
set -uo pipefail        # ไม่ใส่ -e เพราะจะจัดการ error เอง

servers=(web1 web2 web3 db1 db2)
declare -A pid_of
declare -A result

# เริ่มทุกงานพร้อมกัน
for s in "${servers[@]}"; do
    ssh -n "$s" 'systemctl is-active nginx' > "/tmp/check_$s.out" 2>&1 &
    pid_of[$s]=$!
done

# รอทีละตัว เก็บผล
failed=0
for s in "${servers[@]}"; do
    if wait "${pid_of[$s]}"; then
        result[$s]="OK"
    else
        result[$s]="FAIL"
        (( failed++ ))
    fi
done

# สรุป
for s in "${servers[@]}"; do
    printf '%-8s %s\n' "$s" "${result[$s]}"
done

exit $(( failed > 0 ? 1 : 0 ))

5 SSH พร้อมกัน — เสร็จในเวลาของตัวที่ช้าสุด ไม่ใช่ผลรวม

wait -n — รอตัวใดตัวหนึ่งจบก่อน (bash 4.3+)

for url in "${urls[@]}"; do
    download "$url" &
done

# ประมวลผลทันทีที่แต่ละตัวเสร็จ ไม่ต้องรอครบ
completed=0
total=${#urls[@]}
while (( completed < total )); do
    wait -n                       # รอ "ตัวใดก็ได้" จบ
    (( completed++ ))
    echo "เสร็จแล้ว $completed/$total"
done

wait -n (bash 5.1+ รับ PID list ได้ wait -n "${pids[@]}") มีประโยชน์มากสำหรับ progress และ worker pool

จำกัดจำนวนที่รันพร้อมกัน

รัน 100 งานพร้อมกัน = ระบบล่ม จำกัดไว้สัก 4–8

max_jobs=4
running=0

for item in "${items[@]}"; do
    process "$item" &

    (( running++ ))
    if (( running >= max_jobs )); then
        wait -n                   # รอสักตัวจบก่อนเริ่มตัวใหม่ (bash 4.3+)
        (( running-- ))
    fi
done
wait                              # รอที่เหลือ

วิธีที่ง่ายกว่า — ใช้ xargs -P (บทที่ 26) หรือ GNU parallel

printf '%s\n' "${items[@]}" | xargs -P4 -I{} ./process.sh {}

nohup และ disown — ให้รอดหลังปิด terminal

# nohup — ไม่สนใจ SIGHUP (สัญญาณตอน terminal ปิด) + เปลี่ยน output ไปไฟล์
nohup ./long_job.sh > job.log 2>&1 &
echo $! > job.pid

# disown — ถอดงานออกจากรายการ job ของ shell (ไม่โดนฆ่าตอน shell ออก)
./long_job.sh &
disown                            # หรือ disown %1

# รวมกัน — best practice สำหรับงานยาวผ่าน SSH
nohup ./deploy.sh > deploy.log 2>&1 &
disown

จริง ๆ สำหรับงานยาวผ่าน SSH tmux หรือ screen ดีกว่า (บทที่ 37 ของซีรีส์ Linux) — ต่อกลับมาดูได้ ไม่ใช่แค่ปล่อยให้รัน

กับดัก: & กับ set -e

set -e
false &                          # งานเบื้องหลังล้มเหลว
wait                             # ← ตรงนี้ต่างหากที่อาจทำสคริปต์หยุด
echo "ถึงตรงนี้ไหม?"

set -e ไม่หยุดตอน false & (background job) แต่ wait ที่คืน non-zero อาจหยุด ตรวจ exit status ของ wait เองชัด ๆ ดีกว่าพึ่ง set -e

กับดัก: ตัวแปรใน background job

result=""
{ result="ได้ค่าแล้ว"; } &        # subshell — result ในแม่ไม่เปลี่ยน
wait
echo "$result"                    # ว่าง

# ต้องผ่านไฟล์หรือ fd
{ compute > /tmp/result.$$; } &
wait
result=$(</tmp/result.$$)

เรื่องที่คนมักพลาด

  • cmd & แล้วไม่ wait — สคริปต์จบก่อนงานเบื้องหลัง งานอาจถูกฆ่ากลางคัน
  • ไม่เช็ก exit status ของงานเบื้องหลัง — ต้อง wait "$pid" แล้วดู $? ต่องาน
  • $! เก็บช้าไป — มันเก็บแค่ตัวล่าสุด เก็บทันทีหลัง cmd &
  • รัน job เยอะเกินพร้อมกัน — ระบบล่ม จำกัดด้วย wait -n loop หรือ xargs -P
  • ssh ใน background loop กิน stdin — ใส่ ssh -n
  • ตัวแปรที่ตั้งใน { ...; } & ไม่กลับมา — subshell ผ่านไฟล์/fd
  • wait -n บน bash < 4.3 — ไม่มี ใช้ polling jobs หรืออัปเกรด

สรุป

  • cmd & รันเบื้องหลัง — $! = PID (เก็บทันที)
  • wait "$pid" คืน exit status ของงานนั้น — วิธีเดียวที่รู้ว่างานเบื้องหลังสำเร็จไหม
  • wait (ไม่ระบุ) = รอทุกงาน, wait -n = รอตัวใดตัวหนึ่ง (bash 4.3+, ดีสำหรับ progress)
  • รันขนาน: เริ่มทุกงานด้วย & เก็บ PID ใน array → wait ทีละตัวเก็บผล
  • จำกัดจำนวนพร้อมกัน: wait -n loop หรือ xargs -P N (ง่ายกว่า)
  • nohup cmd &> log & disown ให้รอดหลังปิด terminal — แต่ tmux ดีกว่าสำหรับงานยาว
  • jobs/fg/bg/Ctrl+Z ส่วนใหญ่ใช้ interactive (job control ปิดในสคริปต์)

บทถัดไปว่าด้วยสัญญาณและ trap — จับ Ctrl+C, ทำความสะอาดตอนสคริปต์จบ, และ trap EXIT