DevOps Bootcamp · Pelajaran

Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang

Jalankan tugas-tugas independen secara bersamaan menggunakan mode paralel xargs dan kumpulan pekerjaan latar belakang yang dikelola.

Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang adalah pelajaran DevOps Bootcamp gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar DevOps Bootcamp, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus DevOps Bootcamp mencakup 4 pelajaran total.

Mengapa Eksekusi Berurutan Lambat

Ketika Anda menjalankan perintah satu demi satu dalam skrip shell, inti CPU akan menganggur. Bayangkan Anda mengubah ukuran 500 gambar: setiap pemanggilan convert menggunakan satu inti, sementara tujuh inti lainnya menganggur.

Paralelisme mengatasi hal ini dengan menjalankan beberapa tugas secara bersamaan. Dua alat utama dalam Bash memudahkan hal tersebut:

xargs -P — membagi daftar input ke dalam N proses pekerja yang berjalan paralel
pekerjaan latar belakang (&) + wait — membuat proses secara manual dan mengumpulkan hasilnya

Pelajaran ini membahas kedua pendekatan tersebut agar Anda dapat memilih alat yang tepat untuk setiap situasi.

Penyegaran Dasar-Dasar xargs

Sebelum menambahkan paralelisme, ingat kembali cara kerja xargs. Perintah ini membaca item dari stdin dan meneruskannya sebagai argumen ke sebuah perintah.

Flag -I {} memungkinkan Anda menempatkan item input di mana saja dalam string perintah, bukan hanya di bagian akhir.

Contoh di bawah mengubah setiap file .txt menjadi huruf besar menggunakan tr. Setiap file diproses satu per satu (dasar pembanding berurutan).

#!/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 flag -P N ke xargs untuk menjalankan hingga N proses secara paralel. xargs mengelola kumpulan pekerja secara otomatis — ketika satu slot tersedia, item berikutnya langsung dimulai.

-P 0 — membuat proses sebanyak jumlah input (gunakan dengan hati-hati pada daftar besar)
-P 4 — menjalankan paling banyak 4 pekerja pada saat yang sama
-n 1 — mengirim tepat satu item input untuk setiap proses yang dipanggil (flag pendamping yang umum)

Gabungan -n 1 -P 4 adalah pola yang paling umum: satu item per pekerja, empat pekerja sekaligus.

#!/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 "$@"' _

Pemrosesan File secara Paralel

Contoh penggunaan praktis: mengompresi banyak file catatan secara bersamaan. Tanpa -P, setiap pemanggilan gzip menghalangi pemanggilan berikutnya. Dengan -P 8, hingga delapan kompresi berjalan sekaligus sehingga semua inti CPU digunakan secara maksimal.

Perhatikan bahwa -n 1 memastikan setiap pekerja paralel menerima tepat satu nama file — hal ini penting ketika nama file mungkin mengandung spasi (pasangkan dengan -d '\n' atau -print0 / -0 agar aman).

#!/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 Tepat

Menetapkan -P terlalu rendah akan menyia-nyiakan inti CPU; terlalu tinggi akan menyebabkan thrashing. Titik awal yang baik adalah jumlah inti CPU logis:

tugas yang dibatasi CPU (kompresi, pengodean): -P $(nproc)
tugas yang dibatasi I/O (pemanggilan jaringan, pembacaan disk): -P $(($(nproc) * 4)) atau lebih tinggi, karena pekerja menghabiskan sebagian besar waktunya untuk menunggu
tugas yang dibatasi memori: hitung available_RAM / task_RAM_usage dan batasi jumlahnya sampai nilai tersebut

nproc mengembalikan jumlah unit pemrosesan yang tersedia, sehingga menjadi pengganti portabel untuk angka yang ditulis 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

Pekerjaan Latar Belakang dengan &

Terkadang Anda memerlukan kontrol yang lebih besar daripada yang disediakan xargs — penanganan kesalahan per pekerjaan, daftar dinamis, atau bentuk argumen yang kompleks. Gunakan operator latar belakang bawaan shell & untuk membuat pekerjaan secara manual.

Menambahkan & ke perintah apa pun akan segera mengembalikan kendali ke skrip. Proses anak berjalan di latar belakang sementara proses induk melanjutkan eksekusi. Panggil wait di akhir untuk menunggu hingga 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."

Membatasi Konkurensi dengan Kumpulan Pekerjaan

Membuat semua pekerjaan sekaligus dengan & dapat menghabiskan memori ketika daftarnya besar. Kumpulan pekerjaan menjaga agar paling banyak N pekerjaan berjalan pada saat yang sama:

Setelah membuat setiap pekerjaan, periksa jumlah pekerjaan latar belakang yang sedang aktif dengan jobs -r | wc -l
Jika jumlahnya mencapai batas, panggil wait -n (Bash 4.3+) untuk menunggu satu pekerjaan mana pun selesai sebelum membuat pekerjaan berikutnya

Pola ini meniru apa yang dilakukan xargs -P secara internal, tetapi memberi Anda fleksibilitas penuh dalam penulisan skrip untuk setiap pekerjaan.

#!/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."

Mengambil Kode Keluar dari Pekerjaan Paralel

Hal penting yang perlu diperhatikan pada pekerjaan latar belakang: jika proses anak gagal, skrip induk tidak otomatis mengetahuinya. Anda harus mengambil PID setiap proses anak dan memeriksa status keluarnya dengan wait <pid>.

Pola di bawah menyimpan setiap PID dalam sebuah larik, lalu melakukan iterasi pada larik tersebut dengan memanggil wait "$pid", yang mengembalikan kode keluar dari proses anak tertentu.

#!/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; }

Pengunduhan Paralel dengan xargs -P

I/O jaringan merupakan contoh klasik untuk paralelisme tingkat tinggi — setiap pekerja menghabiskan sebagian besar waktunya untuk menunggu byte. Contoh di bawah mengambil beberapa URL secara bersamaan dan menyimpan masing-masing ke file dengan nama unik.

Flag penting yang digunakan:

-P 8 — delapan proses curl secara bersamaan
-n 1 — satu URL untuk setiap pemanggilan curl
--create-dirs -o — curl menyimpan hasil ke nama file yang diturunkan

#!/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 yang terdiri dari beberapa baris dengan xargs, Anda harus mengekspornya dengan export -f function_name, lalu memanggilnya melalui bash -c 'function_name "$@"' _ di dalam xargs.

Pola ini membuka kemampuan penulisan skrip penuh di dalam setiap pekerja paralel: pencatatan, penanganan kesalahan, dan logika kondisional — semuanya untuk 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 Kecepatan dengan time

Selalu lakukan pengukuran sebelum menyatakan adanya peningkatan. Bungkus perintah paralel Anda dengan time dan bandingkan dengan dasar pembanding berurutan. Peningkatan kecepatan yang sebenarnya bergantung pada:

kemandirian tugas — tugas tidak boleh berbagi keadaan yang dapat ditulis tanpa kunci
overhead — biaya pembuatan proses (sekitar 5–20 ms masing-masing) penting untuk tugas-tugas kecil
perebutan sumber daya — I/O disk dapat mencapai kapasitas maksimum bahkan sebelum CPU

Pola tolok ukur sederhana ditunjukkan di bawah — jalankan secara berurutan, lalu secara paralel, dan bandingkan waktu 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' _

Pemeriksaan Pengetahuan: Perilaku xargs -P

Uji pemahaman Anda tentang eksekusi paralel dengan xargs -P.

Ringkasan Pelajaran

Sekarang Anda memiliki dua teknik andal untuk eksekusi paralel dalam Bash:

xargs -n 1 -P N — pendekatan paling sederhana; xargs mengelola kumpulan pekerja secara otomatis. Paling sesuai ketika input Anda berupa daftar biasa dan setiap item dipetakan ke satu perintah.
pekerjaan latar belakang (&) + wait — kontrol penuh atas penulisan skrip; penting ketika Anda memerlukan PID untuk setiap pekerjaan, input dinamis, atau penanganan kode keluar yang terperinci. Gunakan wait -n dengan penghitung untuk membatasi konkurensi.

Aturan penting yang perlu diingat:

Ekspor fungsi shell dengan export -f sebelum meneruskannya melalui xargs
Gunakan -print0 / -0 untuk menangani nama file yang mengandung spasi dengan aman
Simpan PID dalam larik dan panggil wait "$pid" secara terpisah untuk mendeteksi kegagalan
Lakukan tolok ukur dengan time — paralelisme hanya memberikan keuntungan ketika overhead tugas lebih besar daripada biaya pembuatan proses
Tetapkan -P $(nproc) untuk beban kerja yang dibatasi CPU dan kelipatan yang lebih tinggi untuk beban kerja yang dibatasi I/O

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang” gratis?

Ya — teks lengkap “Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus DevOps Bootcamp, upgrade ke CoddyKit PRO. Kursus DevOps Bootcamp mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang”?

Jalankan tugas-tugas independen secara bersamaan menggunakan mode paralel xargs dan kumpulan pekerjaan latar belakang yang dikelola. Kamu berlatih DevOps Bootcamp dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai DevOps Bootcamp?

Tidak diperlukan pengalaman sebelumnya. DevOps Bootcamp di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran DevOps Bootcamp ini?

Ya. Setiap pelajaran DevOps Bootcamp menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Membuat Profil Skrip dan Menghindari Subshell yang Tidak Berguna
Paralelisme dengan xargs -P dan Pekerjaan Latar Belakang
Mengorkestrasi Beban Kerja dengan GNU parallel
Pipeline Streaming dan Named Pipe untuk Throughput

← Kembali ke DevOps Bootcamp