0Pricing
Linux Command Line & Bash Scripting Mastery · Ders

xargs -P ve Arka Plan İşleriyle Paralellik

Bağımsız görevleri xargs paralel modu ve yönetilen arka plan işi havuzlarıyla eşzamanlı çalıştırın.

xargs -P ve Arka Plan İşleriyle Paralellik, CoddyKit'te ücretsiz bir Linux Command Line & Bash Scripting Mastery dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Linux Command Line & Bash Scripting Mastery öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

Sıralı Çalıştırma Neden Yavaştır

Bir kabuk betiğinde komutları art arda çalıştırdığınızda CPU çekirdeklerini boşta bırakırsınız. 500 görüntüyü yeniden boyutlandırmayı düşünün: her convert çağrısı bir çekirdek kullanırken diğer yedi çekirdek boşta kalır.

Paralellik, birden fazla görevi aynı anda dağıtarak bu sorunu çözer. Bash'te bunu kolaylaştıran iki temel araç vardır:

  • xargs -P — bir girdi listesini N paralel çalışan sürece dağıtır
  • Arka plan işleri (&) + wait — süreçleri elle başlatıp sonuçlarını toplar

Bu derste her iki yaklaşım da ele alınır; böylece her durum için doğru aracı seçebilirsiniz.

xargs Temellerini Tazeleme

Paralellik eklemeden önce xargs'ın nasıl çalıştığını hatırlayalım. Standart girdiden öğeleri okur ve bunları bir komuta bağımsız değişken olarak aktarır.

-I {} seçeneği, girdi öğesini komut dizgesinin yalnızca sonuna değil, herhangi bir yerine yerleştirmenizi sağlar.

Aşağıdaki örnek, her .txt dosyasını tr kullanarak büyük harfe dönüştürür. Her dosya aynı anda yalnızca bir tane işlenir (sıralı temel durum).

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

xargs -P Kullanıma Sunuluyor

xargs'a -P N seçeneğini ekleyerek aynı anda en fazla N süreci paralel olarak çalıştırabilirsiniz. xargs çalışan havuzunu otomatik olarak yönetir — bir yuva boşaldığında sonraki öğe hemen başlatılır.

  • -P 0 — girdi sayısı kadar süreç başlatır (büyük listelerde dikkatli kullanın)
  • -P 4 — aynı anda en fazla 4 çalışan süreci etkin tutar
  • -n 1 — çağrılan her sürece tam olarak bir girdi öğesi gönderir (yaygın yardımcı seçenek)

Birlikte kullanıldığında -n 1 -P 4 en yaygın kalıptır: çalışan başına bir öğe, aynı anda dört çalışan.

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

Dosyaları Paralel İşleme

Pratik bir kullanım alanı: çok sayıda günlük dosyasını aynı anda sıkıştırmak. -P olmadan her gzip çağrısı bir sonrakini engeller. -P 8 ile aynı anda en fazla sekiz sıkıştırma çalışır ve tüm CPU çekirdekleri kullanılır.

-n 1'in her paralel çalışana tam olarak bir dosya adı vermesini sağladığına dikkat edin — dosya adları boşluk içerebileceğinde bu kritik önem taşır (güvenlik için -d '\n' veya -print0 / -0 ile birlikte kullanın).

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

Doğru -P Değerini Seçme

-P değerini çok düşük ayarlamak çekirdekleri boşa çıkarır; çok yüksek ayarlamak ise kaynak çekişmesine neden olur. İyi bir başlangıç noktası mantıksal CPU çekirdeği sayısıdır:

  • CPU'ya bağlı görevler (sıkıştırma, kodlama): -P $(nproc)
  • G/Ç'ye bağlı görevler (ağ çağrıları, disk okumaları): çalışanlar zamanlarının çoğunu bekleyerek geçirdiği için -P $(($(nproc) * 4)) veya daha yüksek bir değer
  • Bellekle sınırlı görevler: available_RAM / task_RAM_usage değerini hesaplayın ve üst sınırı bu değere koyun

nproc, kullanılabilir işlem birimlerinin sayısını döndürür; bu nedenle sabit kodlanmış sayıların taşınabilir bir alternatifidir.

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

& ile Arka Plan İşleri

Bazen xargs'ın sunduğundan daha fazla denetime ihtiyaç duyarsınız — iş başına hata yönetimi, dinamik listeler veya karmaşık bağımsız değişken biçimleri gibi. İşleri elle başlatmak için kabuğun yerleşik arka plan işleci &'ni kullanın.

Herhangi bir komuta & eklemek denetimi hemen betiğe geri verir. Alt süreç arka planda çalışırken üst süreç devam eder. Tüm alt süreçler tamamlanana kadar beklemek için sonunda wait çağrısı yapın.

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

İş Havuzuyla Eşzamanlılığı Sınırlama

Tüm işleri & ile aynı anda başlatmak, liste büyük olduğunda belleği tüketebilir. Bir iş havuzu herhangi bir anda en fazla N işin çalışmasını sağlar:

  • Her işi başlattıktan sonra jobs -r | wc -l ile o anda etkin olan arka plan işlerinin sayısını denetleyin
  • Sayı sınıra ulaştığında, bir sonraki işi başlatmadan önce herhangi bir işin tamamlanmasını beklemek için wait -n (Bash 4.3+) çağrısı yapın

Bu kalıp, xargs -P'nin dahili olarak yaptığı işlemi taklit eder; ancak her iş etrafındaki betikleme esnekliğinin tamamını size sunar.

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

Paralel İşlerden Çıkış Kodlarını Alma

Arka plan işlerinde kritik bir konu şudur: bir alt süreç başarısız olursa üst betik bunu otomatik olarak öğrenmez. Her alt sürecin PID'sini almalı ve çıkış durumunu wait <pid> ile denetlemelisiniz.

Aşağıdaki kalıp her PID'yi bir dizide saklar, ardından dizide dolaşarak wait "$pid" çağrısı yapar; bu çağrı ilgili alt sürecin çıkış kodunu döndürür.

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

xargs -P ile Paralel İndirmeler

Ağ G/Ç'si yüksek paralellik için klasik bir örnektir — her çalışan zamanının çoğunu baytları bekleyerek geçirir. Aşağıdaki örnek birden fazla URL'yi eşzamanlı olarak alır ve her birini benzersiz adlandırılmış bir dosyaya kaydeder.

Kullanılan temel seçenekler:

  • -P 8 — aynı anda sekiz curl süreci
  • -n 1 — her curl çağrısı için bir URL
  • --create-dirs -o — curl türetilmiş bir dosya adına kaydeder
#!/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

find, xargs -P ve Kabuk İşlevlerini Birleştirme

Çok satırlı bir kabuk işlevini xargs ile kullanmak için önce export -f function_name ile dışa aktarmanız, ardından xargs içinde bash -c 'function_name "$@"' _ aracılığıyla çağırmanız gerekir.

Bu kalıp her paralel çalışanın içinde tam betikleme gücünü açığa çıkarır: günlük kaydı, hata yönetimi ve koşullu mantık — her öğe için ayrı ayrı.

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

time ile Hızlanmayı Ölçme

Bir kazanım iddiasında bulunmadan önce daima ölçüm yapın. Paralel komutun başına time ekleyin ve sıralı temel durumla karşılaştırın. Gerçek hızlanma şunlara bağlıdır:

  • Görevlerin bağımsızlığı — görevler kilitler olmadan yazılabilir durumu paylaşmamalıdır
  • Ek yük — süreç başlatma maliyeti (her biri yaklaşık 5-20 ms), küçük görevlerde önemlidir
  • Kaynak çekişmesi — CPU tamamen kullanılmadan önce bile disk G/Ç'si doygunluğa ulaşabilir

Aşağıda basit bir karşılaştırma kalıbı gösterilmiştir — önce sıralı, ardından paralel çalıştırın ve real duvar saati sürelerini karşılaştırın.

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

Bilgi Kontrolü: xargs -P Davranışı

xargs -P ile paralel yürütme hakkındaki anlayışınızı sınayın.

Ders Özeti

Artık Bash'te paralel yürütme için iki güvenilir tekniğiniz var:

  • xargs -n 1 -P N — en basit yaklaşım; çalışan havuzunu xargs otomatik olarak yönetir. Girdiniz düz bir liste olduğunda ve her öğe tek bir komuta karşılık geldiğinde en uygunudur.
  • Arka plan işleri (&) + wait — tam betikleme denetimi sağlar; iş başına PID'lere, dinamik girdiye veya ayrıntılı çıkış kodu yönetimine ihtiyaç duyduğunuzda gereklidir. Eşzamanlılığı sınırlamak için bir sayaçla birlikte wait -n kullanın.

İleride uygulamanız gereken temel kurallar:

  • xargs üzerinden aktarmadan önce kabuk işlevlerini export -f ile dışa aktarın
  • Boşluk içeren dosya adlarını güvenli biçimde işlemek için -print0 / -0 kullanın
  • Başarısızlıkları algılamak için PID'leri bir dizide saklayın ve her biri için ayrı ayrı wait "$pid" çağrısı yapın
  • time ile karşılaştırma yapın — paralellik yalnızca görev ek yükü süreç başlatma maliyetini aştığında kazanç sağlar
  • CPU'ya bağlı iş yükleri için -P $(nproc), G/Ç'ye bağlı iş yükleri içinse daha yüksek bir kat kullanın

Sıkça Sorulan Sorular

“xargs -P ve Arka Plan İşleriyle Paralellik” dersi ücretsiz mi?

Evet — “xargs -P ve Arka Plan İşleriyle Paralellik” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Linux Command Line & Bash Scripting Mastery kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Linux Command Line & Bash Scripting Mastery kursu toplamda 4 dersten oluşur.

“xargs -P ve Arka Plan İşleriyle Paralellik” dersinde ne öğreneceğim?

Bağımsız görevleri xargs paralel modu ve yönetilen arka plan işi havuzlarıyla eşzamanlı çalıştırın. Linux Command Line & Bash Scripting Mastery ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Linux Command Line & Bash Scripting Mastery öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Linux Command Line & Bash Scripting Mastery, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“xargs -P ve Arka Plan İşleriyle Paralellik” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Linux Command Line & Bash Scripting Mastery dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Linux Command Line & Bash Scripting Mastery dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. Betikleri Profilleme ve Gereksiz Alt Kabuklardan Kaçınma
  2. xargs -P ve Arka Plan İşleriyle Paralellik
  3. GNU parallel ile İş Yüklerini Orkestre Etme
  4. Veri Akışları ve İş Hacmi için Adlandırılmış Borular
← Linux Command Line & Bash Scripting Mastery Sayfasına Dön