DevOps बूटकैंप · पाठ

xargs -P और बैकग्राउंड जॉब से समानांतरता

xargs के समानांतर मोड और प्रबंधित बैकग्राउंड जॉब समूहों का उपयोग करके स्वतंत्र कार्य एक साथ चलाएँ।

पाठ 2, कुल 4 में से13 चरण

xargs -P और बैकग्राउंड जॉब से समानांतरता, CoddyKit पर DevOps बूटकैंप का एक निःशुल्क पाठ है। यह 4 में से 2वाँ पाठ है। इस अध्ययन पथ के 3 तक कोई भी पाठ पूरा पढ़ना निःशुल्क है — इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ व्यावहारिक अभ्यास भी उपलब्ध कराता है। यह DevOps बूटकैंप सीखने के मार्ग का हिस्सा है और आपकी प्रगति वेब तथा CoddyKit ऐप पर सिंक होती रहती है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

क्रमिक निष्पादन धीमा क्यों है

जब आप शेल स्क्रिप्ट में कमांड को एक के बाद एक चलाते हैं, तो CPU कोर खाली पड़े रहते हैं। 500 चित्रों का आकार बदलने पर विचार कीजिए: प्रत्येक convert कॉल एक कोर का उपयोग करती है, जबकि बाकी सात खाली रहते हैं।

समानांतरता एक साथ कई कार्य भेजकर इस समस्या को ठीक करती है। Bash में दो मुख्य उपकरण इसे आसान बनाते हैं:

xargs -P — आगतों की सूची को N समानांतर कार्यकर्ता प्रक्रियाओं में बाँटता है
पृष्ठभूमि कार्य (&) + wait — प्रक्रियाएँ मैन्युअल रूप से बनाकर उनके पूरा होने की प्रतीक्षा करता है

इस पाठ में दोनों तरीकों को शामिल किया गया है, ताकि आप हर परिस्थिति के लिए सही उपकरण चुन सकें।

xargs के मूल सिद्धांतों का पुनरावलोकन

समानांतरता जोड़ने से पहले याद कर लें कि xargs कैसे काम करता है। यह मानक आगत से आइटम पढ़ता है और उन्हें किसी कमांड के तर्कों के रूप में देता है।

-I {} फ़्लैग आपको आगत आइटम को कमांड स्ट्रिंग में कहीं भी रखने देता है, केवल अंत में नहीं।

नीचे दिया गया उदाहरण प्रत्येक .txt फ़ाइल को tr का उपयोग करके बड़े अक्षरों में बदलता है। प्रत्येक फ़ाइल को एक समय में एक ही संसाधित किया जाता है (क्रमिक आधाररेखा)।

#!/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 का परिचय

xargs में -P N फ़्लैग जोड़कर अधिकतम N प्रक्रियाएँ समानांतर रूप से चलाएँ। xargs कार्यकर्ता समूह को अपने-आप सँभालता है — जैसे ही कोई स्थान खाली होता है, अगला आइटम तुरंत शुरू हो जाता है।

-P 0 — जितने आगत हों उतनी प्रक्रियाएँ बनाएँ (बड़ी सूचियों पर सावधानी से उपयोग करें)
-P 4 — किसी भी समय अधिकतम 4 कार्यकर्ता चलते रहें
-n 1 — प्रत्येक शुरू की गई प्रक्रिया को ठीक एक आगत आइटम भेजें (सामान्य सहायक फ़्लैग)

मिलकर, -n 1 -P 4 सबसे सामान्य प्रतिरूप है: प्रत्येक कार्यकर्ता को एक आइटम और एक साथ चार कार्यकर्ता।

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

फ़ाइलों का समानांतर प्रसंस्करण

एक व्यावहारिक उपयोग: कई लॉग फ़ाइलों को एक साथ संपीड़ित करना। -P के बिना प्रत्येक gzip कॉल अगली कॉल को रोक देती है। -P 8 के साथ एक बार में अधिकतम आठ संपीड़न चलते हैं और सभी CPU कोर का पूरा उपयोग होता है।

ध्यान दें कि -n 1 यह सुनिश्चित करता है कि प्रत्येक समानांतर कार्यकर्ता को ठीक एक फ़ाइल नाम मिले — यह तब महत्वपूर्ण है जब फ़ाइल नामों में रिक्त स्थान हो सकते हैं (सुरक्षा के लिए -d '\n' या -print0 / -0 के साथ प्रयोग करें)।

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

सही -P मान चुनना

-P को बहुत कम रखने पर कोर का उपयोग व्यर्थ होता है; बहुत अधिक रखने पर अत्यधिक अदला-बदली होती है। एक अच्छा प्रारंभिक मान तार्किक CPU कोर की संख्या है:

CPU-प्रधान कार्य (संपीड़न, एन्कोडिंग): -P $(nproc)
आगत-निर्गत प्रधान कार्य (नेटवर्क कॉल, डिस्क पठन): -P $(($(nproc) * 4)) या इससे अधिक, क्योंकि कार्यकर्ता अधिकांश समय प्रतीक्षा करते हैं
स्मृति-सीमित कार्य: available_RAM / task_RAM_usage की गणना करें और उसी पर सीमा तय करें

nproc उपलब्ध प्रसंस्करण इकाइयों की संख्या लौटाता है, इसलिए यह पहले से लिखी संख्या का विभिन्न प्रणालियों पर चलने योग्य विकल्प है।

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

& के साथ पृष्ठभूमि कार्य

कभी-कभी आपको xargs से अधिक नियंत्रण चाहिए — प्रत्येक कार्य के लिए अलग त्रुटि प्रबंधन, गतिशील सूचियाँ या जटिल तर्क संरचनाएँ। कार्यों को मैन्युअल रूप से शुरू करने के लिए शेल के अंतर्निर्मित पृष्ठभूमि ऑपरेटर & का उपयोग करें।

किसी भी कमांड के अंत में & लगाने पर नियंत्रण तुरंत स्क्रिप्ट को वापस मिल जाता है। मूल प्रक्रिया आगे चलती रहती है और संतति प्रक्रिया पृष्ठभूमि में चलती है। सभी संतति प्रक्रियाओं के पूरा होने तक रुकने के लिए अंत में wait कॉल करें।

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

कार्य समूह से समानांतरता सीमित करना

& के साथ सभी कार्य एक साथ शुरू करने पर बड़ी सूची की स्थिति में स्मृति समाप्त हो सकती है। एक कार्य समूह किसी भी समय अधिकतम N कार्यों को चलाता है:

प्रत्येक कार्य शुरू करने के बाद jobs -r | wc -l से जाँचें कि इस समय कितने पृष्ठभूमि कार्य सक्रिय हैं
यदि संख्या सीमा तक पहुँच जाए, तो अगला कार्य शुरू करने से पहले wait -n (Bash 4.3+) कॉल करके किसी एक कार्य के पूरा होने की प्रतीक्षा करें

यह प्रतिरूप आंतरिक रूप से xargs -P के काम करने की नकल करता है, लेकिन प्रत्येक कार्य के आसपास स्क्रिप्ट लिखने की पूरी सुविधा देता है।

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

समानांतर कार्यों से निकास कोड प्राप्त करना

पृष्ठभूमि कार्यों से जुड़ी एक महत्वपूर्ण चिंता यह है कि यदि कोई संतति प्रक्रिया विफल हो जाए, तो मूल स्क्रिप्ट को इसका स्वतः पता नहीं चलता। आपको प्रत्येक संतति प्रक्रिया का PID सहेजना होगा और wait <pid> से उसकी निकास स्थिति जाँचनी होगी।

नीचे दिया गया प्रतिरूप प्रत्येक PID को एक सरणी में सहेजता है, फिर सरणी पर चलते हुए wait "$pid" कॉल करता है, जो उस विशिष्ट संतति प्रक्रिया का निकास कोड लौटाता है।

#!/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 के साथ समानांतर डाउनलोड

नेटवर्क आगत-निर्गत उच्च समानांतरता का आदर्श उदाहरण है — प्रत्येक कार्यकर्ता अपना अधिकांश समय बाइट आने की प्रतीक्षा में बिताता है। नीचे दिया गया उदाहरण कई URL को एक साथ प्राप्त करता है और प्रत्येक को विशिष्ट नाम वाली फ़ाइल में सहेजता है।

उपयोग किए गए मुख्य फ़्लैग:

-P 8 — एक साथ आठ curl प्रक्रियाएँ
-n 1 — प्रत्येक curl आह्वान के लिए एक URL
--create-dirs -o — curl से व्युत्पन्न फ़ाइल नाम में सहेजना

#!/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 और शेल फ़ंक्शन को मिलाना

xargs के साथ बहु-पंक्ति शेल फ़ंक्शन का उपयोग करने के लिए आपको उसे export -f function_name से निर्यात करना होगा, फिर xargs के अंदर bash -c 'function_name "$@"' _ के माध्यम से उसका आह्वान करना होगा।

यह प्रतिरूप प्रत्येक समानांतर कार्यकर्ता के अंदर पूरी स्क्रिप्टिंग शक्ति उपलब्ध कराता है: लॉग लिखना, त्रुटि प्रबंधन और सशर्त तर्क — प्रत्येक आइटम के लिए अलग-अलग।

#!/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 से गति-वृद्धि मापना

सुधार का दावा करने से पहले हमेशा मापें। अपने समानांतर कमांड को time से लपेटें और क्रमिक आधाररेखा से तुलना करें। वास्तविक गति-वृद्धि इन बातों पर निर्भर करती है:

कार्य की स्वतंत्रता — लॉक के बिना कार्यों को लिखने योग्य स्थिति साझा नहीं करनी चाहिए
अतिरिक्त लागत — प्रक्रिया शुरू करने की लागत (प्रत्येक में लगभग 5-20 मिलीसेकंड) छोटे कार्यों के लिए महत्वपूर्ण होती है
संसाधन प्रतिस्पर्धा — CPU के पूरी तरह व्यस्त होने से पहले ही डिस्क आगत-निर्गत अपनी अधिकतम क्षमता तक पहुँच सकता है

नीचे एक सरल मानदंड प्रतिरूप दिखाया गया है — पहले क्रमिक, फिर समानांतर चलाएँ और 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' _

ज्ञान जाँच: xargs -P का व्यवहार

xargs -P के साथ समानांतर निष्पादन की अपनी समझ जाँचिए।

इंटरैक्टिव पाठ में इसका उत्तर दें

पाठ का पुनरावलोकन

अब आपके पास Bash में समानांतर निष्पादन की दो विश्वसनीय तकनीकें हैं:

xargs -n 1 -P N — सबसे सरल तरीका; xargs कार्यकर्ता समूह को अपने-आप सँभालता है। तब सबसे अच्छा है जब आपका आगत साधारण सूची हो और प्रत्येक आइटम एक कमांड से जुड़ा हो।
पृष्ठभूमि कार्य (&) + wait — स्क्रिप्ट पर पूरा नियंत्रण; तब आवश्यक है जब आपको प्रत्येक कार्य का PID, गतिशील आगत या निकास कोड का सूक्ष्म प्रबंधन चाहिए। समानांतरता सीमित करने के लिए गणक के साथ wait -n का उपयोग करें।

आगे के लिए मुख्य नियम:

xargs के माध्यम से भेजने से पहले शेल फ़ंक्शन को export -f से निर्यात करें
रिक्त स्थान वाले फ़ाइल नामों को सुरक्षित रूप से सँभालने के लिए -print0 / -0 का उपयोग करें
विफलताओं का पता लगाने के लिए PID को एक सरणी में सहेजें और प्रत्येक के लिए अलग-अलग wait "$pid" कॉल करें
time से मानदंड परीक्षण करें — समानांतरता तभी लाभ देती है जब कार्य की अतिरिक्त लागत प्रक्रिया शुरू करने की लागत से अधिक हो
CPU-प्रधान कार्यभार के लिए -P $(nproc) और आगत-निर्गत प्रधान कार्यभार के लिए इससे अधिक गुणक रखें

शुरुआत निःशुल्क

एआई शिक्षक के साथ DevOps बूटकैंप सीखें — निःशुल्क

अपने ब्राउज़र में वास्तविक कोड लिखें और चलाएँ, चौबीसों घंटे एआई शिक्षक से तुरंत सहायता पाएँ, और वेब या ऐप पर वहीं से शुरू करें जहाँ आपने छोड़ा था।

पाठ्यक्रम: 142
पाठ: 568

निःशुल्क सीखना शुरू करें पूरा पाठ्यक्रम देखें

अक्सर पूछे जाने वाले प्रश्न

क्या “xargs -P और बैकग्राउंड जॉब से समानांतरता” पाठ निःशुल्क है?

हाँ — DevOps बूटकैंप अध्ययन पथ के 3 तक कोई भी पाठ, जिसमें “xargs -P और बैकग्राउंड जॉब से समानांतरता” भी शामिल है, यहाँ वेब पर पूरा पढ़ना निःशुल्क है। इसके बाद CoddyKit PRO हर पाठ अनलॉक करता है, साथ ही अंतर्निर्मित कोड संपादक और चौबीसों घंटे एआई शिक्षक के साथ इंटरैक्टिव अभ्यास भी उपलब्ध कराता है। DevOps बूटकैंप पाठ्यक्रम में कुल 4 पाठ शामिल हैं।

“xargs -P और बैकग्राउंड जॉब से समानांतरता” में मैं क्या सीखूँगा?

xargs के समानांतर मोड और प्रबंधित बैकग्राउंड जॉब समूहों का उपयोग करके स्वतंत्र कार्य एक साथ चलाएँ। आप ब्राउज़र में सीधे चलाए जाने वाले व्यावहारिक कोड के साथ DevOps बूटकैंप का अभ्यास करते हैं, और पाठ पूरा करते समय 24/7 एआई ट्यूटर आपके प्रश्नों के उत्तर देता है।

क्या DevOps बूटकैंप शुरू करने के लिए मुझे किसी अनुभव की आवश्यकता है?

पहले के अनुभव की आवश्यकता नहीं है। CoddyKit पर DevOps बूटकैंप शुरुआती से लेकर उन्नत शिक्षार्थियों तक सभी के लिए व्यवस्थित किया गया है, इसलिए आप यहीं से या शुरुआत से सीखना शुरू कर सकते हैं और अपनी गति से आगे बढ़ सकते हैं। यह 4 में से 2वाँ पाठ है।

“xargs -P और बैकग्राउंड जॉब से समानांतरता” पाठ पूरा करने में कितना समय लगता है?

CoddyKit का अधिकांश पाठ लगभग 5–10 मिनट में पूरा हो जाता है। हर पाठ छोटा और संवादात्मक है, इसलिए आप लगातार प्रगति करते हैं और वेब या ऐप पर वहीं से सीखना जारी रख सकते हैं जहाँ आपने छोड़ा था।

क्या मैं इस DevOps बूटकैंप पाठ में कोड लिख और चला सकता हूँ?

हाँ। हर DevOps बूटकैंप पाठ में एक अंतर्निर्मित कोड संपादक शामिल है, जिससे आप सीधे अपने ब्राउज़र में वास्तविक कोड लिख और चला सकते हैं और तुरंत एआई प्रतिक्रिया पा सकते हैं—स्थानीय सेटअप की आवश्यकता नहीं है।

इस पाठ्यक्रम के सभी पाठ

स्क्रिप्ट की प्रोफ़ाइलिंग और बेकार सबशेल से बचाव
xargs -P और बैकग्राउंड जॉब से समानांतरता
GNU parallel से कार्यभार का संचालन
थ्रूपुट के लिए स्ट्रीमिंग पाइपलाइन और नामित पाइप

← DevOps बूटकैंप पर वापस जाएँ