Penguasaan Baris Perintah Linux & Penskripan Bash · Pelajaran

Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang

Jalankan tugas bebas secara serentak menggunakan mod selari xargs dan kumpulan kerja latar belakang yang diurus

Pelajaran 2 daripada 413 langkah

Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang ialah pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Penguasaan Baris Perintah Linux & Penskripan Bash, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Penguasaan Baris Perintah Linux & Penskripan Bash merangkumi sejumlah 4 pelajaran.

Mengapa Berjujukan Itu Perlahan

Apabila Anda menjalankan arahan satu demi satu dalam skrip shell, teras CPU tidak digunakan. Pertimbangkan proses mengubah saiz 500 imej: setiap panggilan convert menggunakan satu teras, manakala tujuh teras yang lain tidak digunakan.

Pemprosesan selari menyelesaikan masalah ini dengan menghantar beberapa tugas secara serentak. Dua alat utama dalam Bash memudahkannya:

xargs -P — mengagihkan senarai input kepada N proses pekerja yang berjalan selari
Kerja latar (&) + wait — mencipta proses secara manual dan mengumpulkannya

Pelajaran ini merangkumi kedua-dua pendekatan supaya Anda dapat memilih alat yang sesuai untuk setiap keadaan.

Penyegaran Asas xargs

Sebelum menambahkan pemprosesan selari, ingat semula cara xargs berfungsi. Ia membaca item daripada stdin dan menghantarkannya sebagai argumen kepada suatu arahan.

Bendera -I {} membolehkan Anda meletakkan item input di mana-mana dalam rentetan arahan, bukan hanya di hujung.

Contoh di bawah menukar setiap fail .txt kepada huruf besar menggunakan tr. Setiap fail diproses satu demi satu (garis dasar berjujukan).

#!/usr/bin/env bash
# Create sample files
mkdir -p /tmp/xargs_demo
for i in 1 2 3; do
  echo "hello world $i" > /tmp/xargs_demo/file$i.txt
done

# Process files one at a time (sequential)
find /tmp/xargs_demo -name '*.txt' | xargs -I {} sh -c 'tr a-z A-Z < "$1"' _ {}

# Cleanup
rm -rf /tmp/xargs_demo

Memperkenalkan xargs -P

Tambahkan bendera -P N kepada xargs untuk menjalankan sehingga N proses secara selari. xargs mengurus kumpulan pekerja secara automatik — apabila satu slot tersedia, item seterusnya bermula serta-merta.

-P 0 — cipta sebanyak proses yang sepadan dengan jumlah input (gunakan dengan berhati-hati untuk senarai besar)
-P 4 — jalankan paling banyak 4 pekerja pada satu-satu masa
-n 1 — hantarkan tepat satu item input bagi setiap proses yang dipanggil (bendera pasangan yang lazim)

Gabungan -n 1 -P 4 ialah pola yang paling lazim: satu item bagi setiap pekerja, empat pekerja pada satu-satu masa.

#!/usr/bin/env bash
# Simulate 8 tasks, each taking ~1 second
# Sequential would take ~8s; parallel with -P 4 takes ~2s

process_item() {
  local item="$1"
  sleep 1
  echo "Done: $item"
}
export -f process_item

time printf '%s\n' task{1..8} | xargs -n 1 -P 4 bash -c 'process_item "$@"' _

Pemprosesan Fail Secara Selari

Contoh penggunaan praktikal: mampatkan banyak fail log secara serentak. Tanpa -P, setiap panggilan gzip menghalang panggilan seterusnya. Dengan -P 8, sehingga lapan pemampatan berjalan serentak dan menggunakan semua teras CPU.

Perhatikan bahawa -n 1 memastikan setiap pekerja selari menerima tepat satu nama fail — amat penting apabila nama fail mungkin mengandungi ruang (gabungkan dengan -d '\n' atau -print0 / -0 untuk keselamatan).

#!/usr/bin/env bash
# Create dummy log files
mkdir -p /tmp/logs_demo
for i in $(seq 1 12); do
  dd if=/dev/urandom bs=1K count=64 2>/dev/null > /tmp/logs_demo/app_$i.log
done

echo "Files before: $(ls /tmp/logs_demo | wc -l)"

# Compress all .log files in parallel (up to 8 workers)
find /tmp/logs_demo -name '*.log' -print0 \
  | xargs -0 -n 1 -P 8 gzip --fast

echo "Files after : $(ls /tmp/logs_demo | wc -l)"
rm -rf /tmp/logs_demo

Memilih Nilai -P yang Sesuai

Menetapkan -P terlalu rendah membazirkan teras; menetapkannya terlalu tinggi menyebabkan kesibukan berlebihan. Titik permulaan yang baik ialah bilangan teras CPU logik:

Tugas terikat CPU (pemampatan, pengekodan): -P $(nproc)
Tugas terikat I/O (panggilan rangkaian, bacaan cakera): -P $(($(nproc) * 4)) atau lebih tinggi, kerana pekerja menghabiskan kebanyakan masa untuk menunggu
Tugas yang terhad oleh memori: kira available_RAM / task_RAM_usage dan hadkan pada nilai tersebut

nproc mengembalikan bilangan unit pemprosesan yang tersedia, menjadikannya pengganti mudah alih untuk nombor yang ditetapkan secara tetap.

#!/usr/bin/env bash
CORES=$(nproc)
IO_WORKERS=$(( CORES * 4 ))

echo "CPU cores   : $CORES"
echo "CPU-bound -P: $CORES"
echo "I/O-bound -P: $IO_WORKERS"

# Example: parallel curl downloads (I/O-bound)
# printf '%s\n' url1 url2 ... | xargs -n 1 -P "$IO_WORKERS" curl -sSO

Kerja Latar dengan &

Kadangkala Anda memerlukan lebih banyak kawalan berbanding yang disediakan oleh xargs — pengendalian ralat bagi setiap kerja, senarai dinamik atau bentuk argumen yang kompleks. Gunakan operator latar terbina dalam shell & untuk mencipta kerja secara manual.

Menambahkan & pada mana-mana arahan mengembalikan kawalan kepada skrip serta-merta. Proses anak berjalan di latar manakala proses induk meneruskan pelaksanaan. Panggil wait pada penghujung untuk menunggu sehingga semua proses anak selesai.

#!/usr/bin/env bash
process() {
  local id="$1"
  sleep $(( RANDOM % 3 + 1 ))
  echo "Job $id finished at $(date +%T)"
}

echo "Launching 5 background jobs..."
for id in $(seq 1 5); do
  process "$id" &
done

wait   # Block until every background job completes
echo "All jobs done."

Mengehadkan Keserentakan dengan Kumpulan Kerja

Mencipta semua kerja serentak dengan & boleh menghabiskan memori apabila senarainya besar. Kumpulan kerja memastikan paling banyak N kerja berjalan pada satu-satu masa:

Selepas mencipta setiap kerja, semak bilangan kerja latar yang sedang aktif dengan jobs -r | wc -l
Jika kiraan mencapai had, panggil wait -n (Bash 4.3+) untuk menunggu mana-mana satu kerja selesai sebelum mencipta kerja seterusnya

Pola ini meniru perkara yang dilakukan oleh xargs -P secara dalaman, tetapi memberikan Anda fleksibiliti penuh untuk menulis skrip di sekeliling setiap kerja.

#!/usr/bin/env bash
MAX_JOBS=3

process() {
  local id="$1"
  sleep $(( RANDOM % 3 + 1 ))
  echo "Task $id done"
}

for id in $(seq 1 10); do
  # Throttle: wait for a slot if pool is full
  while (( $(jobs -r | wc -l) >= MAX_JOBS )); do
    wait -n 2>/dev/null || true
  done
  process "$id" &
done

wait
echo "All 10 tasks complete."

Merekod Kod Keluar daripada Kerja Selari

Perkara penting tentang kerja latar: jika proses anak gagal, skrip induk tidak mengetahuinya secara automatik. Anda mesti merekod PID setiap proses anak dan menyemak status keluarnya dengan wait <pid>.

Pola di bawah menyimpan setiap PID dalam tatasusunan, kemudian mengulangi tatasusunan itu sambil memanggil wait "$pid", yang mengembalikan kod keluar bagi proses anak tertentu tersebut.

#!/usr/bin/env bash
set -euo pipefail

task() {
  local id="$1"
  sleep 1
  if (( id == 3 )); then
    echo "Task $id: FAILED" >&2
    return 1
  fi
  echo "Task $id: ok"
}

pids=()
for id in $(seq 1 5); do
  task "$id" &
  pids+=("$!")
done

failed=0
for pid in "${pids[@]}"; do
  if ! wait "$pid"; then
    echo "PID $pid exited with error" >&2
    (( failed++ ))
  fi
done

(( failed == 0 )) && echo "All OK" || { echo "$failed job(s) failed"; exit 1; }

Muat Turun Selari dengan xargs -P

I/O rangkaian ialah contoh klasik untuk keserentakan tinggi — setiap pekerja menghabiskan kebanyakan masanya menunggu bait. Contoh di bawah mengambil beberapa URL secara serentak dan menyimpan setiap satunya sebagai fail dengan nama unik.

Bendera utama yang digunakan:

-P 8 — lapan proses curl serentak
-n 1 — satu URL bagi setiap panggilan curl
--create-dirs -o — curl menyimpan output menggunakan nama fail yang terbit

#!/usr/bin/env bash
# Download several small public files in parallel
URLs=(
  "https://httpbin.org/bytes/1024"
  "https://httpbin.org/bytes/2048"
  "https://httpbin.org/bytes/512"
  "https://httpbin.org/bytes/4096"
)

mkdir -p /tmp/parallel_dl

printf '%s\n' "${URLs[@]}" | xargs -n 1 -P 4 bash -c '
  url="$1"
  out="/tmp/parallel_dl/$(echo "$url" | md5sum | cut -c1-8).bin"
  curl -sSf "$url" -o "$out" && echo "Saved $out"
' _

ls -lh /tmp/parallel_dl/
rm -rf /tmp/parallel_dl

Menggabungkan find, xargs -P dan Fungsi Shell

Untuk menggunakan fungsi shell berbilang baris dengan xargs, Anda mesti mengeksportnya dengan export -f function_name, kemudian memanggilnya melalui bash -c 'function_name "$@"' _ di dalam xargs.

Pola ini membuka keupayaan penulisan skrip penuh dalam setiap pekerja selari: pencatatan log, pengendalian ralat dan logik bersyarat — semuanya bagi setiap item.

#!/usr/bin/env bash
mkdir -p /tmp/proc_demo
for i in $(seq 1 8); do echo "data $i" > /tmp/proc_demo/item_$i.txt; done

process_file() {
  local f="$1"
  local base
  base=$(basename "$f" .txt)
  # Simulate work: count words and append a timestamp
  local wc
  wc=$(wc -w < "$f")
  echo "[$base] words=$wc processed=$(date +%T)" >> "/tmp/proc_demo/${base}.result"
}
export -f process_file

find /tmp/proc_demo -name '*.txt' -print0 \
  | xargs -0 -n 1 -P "$(nproc)" bash -c 'process_file "$@"' _

grep '' /tmp/proc_demo/*.result
rm -rf /tmp/proc_demo

Mengukur Peningkatan Kelajuan dengan time

Sentiasa buat pengukuran sebelum mendakwa terdapat peningkatan. Bungkus arahan selari Anda dengan time dan bandingkan dengan garis dasar berjujukan. Peningkatan kelajuan sebenar bergantung pada:

Kebebasan tugas — tugas tidak boleh berkongsi keadaan yang boleh ditulis tanpa kunci
Overhed — kos mencipta proses (kira-kira 5–20 ms setiap satu) penting bagi tugas kecil
Perebutan sumber — I/O cakera boleh mencapai hadnya sebelum CPU

Pola penanda aras ringkas ditunjukkan di bawah — jalankan secara berjujukan, kemudian secara selari, dan bandingkan masa jam dinding real.

#!/usr/bin/env bash
work() { sleep 0.2; }   # simulate a 200ms task
export -f work

ITEMS=$(seq 1 16)

echo "=== Sequential ==="
time printf '%s\n' $ITEMS | xargs -n 1 bash -c 'work' _

echo
echo "=== Parallel ($(nproc) workers) ==="
time printf '%s\n' $ITEMS | xargs -n 1 -P "$(nproc)" bash -c 'work' _

Semakan Pengetahuan: Tingkah Laku xargs -P

Uji pemahaman Anda tentang pelaksanaan selari dengan xargs -P.

Jawab dalam pelajaran interaktif

Rumusan Pelajaran

Kini Anda mempunyai dua teknik yang boleh dipercayai untuk pelaksanaan selari dalam Bash:

xargs -n 1 -P N — pendekatan paling mudah; xargs mengurus kumpulan pekerja secara automatik. Terbaik apabila input Anda ialah senarai biasa dan setiap item dipetakan kepada satu arahan.
Kerja latar (&) + wait — kawalan penuh terhadap penulisan skrip; penting apabila Anda memerlukan PID bagi setiap kerja, input dinamik atau pengendalian kod keluar yang terperinci. Gunakan wait -n bersama pembilang untuk mengehadkan keserentakan.

Peraturan utama untuk diingati:

Eksport fungsi shell dengan export -f sebelum menghantarkannya melalui xargs
Gunakan -print0 / -0 untuk mengendalikan nama fail yang mengandungi ruang dengan selamat
Simpan PID dalam tatasusunan dan panggil wait "$pid" secara berasingan untuk mengesan kegagalan
Buat penanda aras dengan time — pemprosesan selari hanya memberikan manfaat apabila overhed tugas melebihi kos penciptaan proses
Tetapkan -P $(nproc) untuk beban kerja terikat CPU dan gandaan yang lebih tinggi untuk beban kerja terikat I/O

Percuma untuk bermula

Pelajari Bash dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 22
Pelajaran: 88

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang” percuma?

Ya — teks penuh “Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Penguasaan Baris Perintah Linux & Penskripan Bash, tingkat taraf kepada CoddyKit PRO. Kursus Penguasaan Baris Perintah Linux & Penskripan Bash merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang”?

Jalankan tugas bebas secara serentak menggunakan mod selari xargs dan kumpulan kerja latar belakang yang diurus Anda berlatih Penguasaan Baris Perintah Linux & Penskripan Bash menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Penguasaan Baris Perintah Linux & Penskripan Bash?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Penguasaan Baris Perintah Linux & Penskripan Bash di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash ini?

Ya. Setiap pelajaran Penguasaan Baris Perintah Linux & Penskripan Bash menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

Menganalisis Prestasi Skrip dan Mengelakkan Subcangkerang Tidak Berguna
Pemprosesan Selari dengan xargs -P dan Kerja Latar Belakang
Mengatur Beban Kerja dengan GNU parallel
Saluran Paip Penstriman dan Paip Bernama untuk Daya Pemprosesan

← Kembali ke Penguasaan Baris Perintah Linux & Penskripan Bash