जवाबों:
कैसा रहेगा:
prog1 & prog2 && fgयह करेगा:
prog1।prog2, और इसे अग्रभूमि में रखें , ताकि आप इसे बंद कर सकें ctrl-c।prog2है, तो आप में लौट जाएँगे prog1के अग्रभूमि , तो आप ऐसा भी पास इसके साथ कर सकते हैं ctrl-c।prog1जब prog2समाप्त? विचार करें node srv.js & cucumberjs
prog1 & prog2 ; fg यह एक बार में कई ssh सुरंगों को चलाने के लिए था। आशा है कि यह किसी की मदद करता है।
prog2तुरंत चलाने में विफल रहता है, तो आप prog1अग्रभूमि में वापस आ जाएंगे । यदि यह वांछनीय है, तो यह ठीक है।
prog1 & prog2 && kill $!।
आप उपयोग कर सकते हैं wait:
some_command &
P1=$!
other_command &
P2=$!
wait $P1 $P2यह पृष्ठभूमि प्रोग्राम $!PID को चर ( अंतिम लॉन्च की गई प्रक्रिया 'PID) प्रदान करता है, फिर waitकमांड उनका इंतजार करता है। यह अच्छा है क्योंकि यदि आप स्क्रिप्ट को मारते हैं, तो यह प्रक्रियाओं को भी मारता है!
#!/usr/bin/env bash ARRAY='cat bat rat' for ARR in $ARRAY do ./run_script1 $ARR & done P1=$! wait $P1 echo "INFO: Execution of all background processes in the for loop has completed.."
${}इसे एक स्ट्रिंग सूची या इसी तरह से प्रक्षेपित करने के लिए उपयोग करना होगा।
GNU समानांतर के साथ http://www.gnu.org/software/parallel/ यह उतना ही आसान है:
(echo prog1; echo prog2) | parallelया यदि आप पसंद करते हैं:
parallel ::: prog1 prog2और अधिक जानें:
parallelविभिन्न सिंटैक्स के साथ अलग- अलग संस्करण हैं । उदाहरण के लिए, डेबियन डेरिवेटिव पर moreutilsपैकेज में एक अलग कमांड होता है, जिसे parallelकाफी अलग तरह से व्यवहार किया जाता है ।
parallelका उपयोग कर की तुलना में बेहतर &?
parallelबेहतर है जब कोर की तुलना में अधिक नौकरियां हैं, जिस स्थिति &में एक बार में एक से अधिक नौकरियां चलेंगी। (cf. pigeonhole सिद्धांत )
यदि आप आसानी से एकाधिक प्रक्रिया को चलाने और मारने में सक्षम होना चाहते हैं ctrl-c, तो यह मेरी पसंदीदा विधि है: एक (…)उपधारा में कई पृष्ठभूमि प्रक्रियाओं को स्पॉन करें , और SIGINTनिष्पादित करने के लिए जाल kill 0, जो सबसहेल समूह में पैदा की गई हर चीज को मार देगा:
(trap 'kill 0' SIGINT; prog1 & prog2 & prog3)आपके पास जटिल प्रक्रिया निष्पादन संरचनाएं हो सकती हैं, और सब कुछ एक के साथ बंद हो जाएगा ctrl-c(बस सुनिश्चित करें कि अंतिम प्रक्रिया अग्रभूमि में चलती है, अर्थात, &बाद में शामिल न करें prog1.3):
(trap 'kill 0' SIGINT; prog1.1 && prog1.2 & (prog2.1 | prog2.2 || prog2.3) & prog1.3)xargs -P <n>आपको <n>समानांतर में कमांड चलाने की अनुमति देता है ।
जबकि -Pएक गैरमानक विकल्प है, दोनों GNU (लिनक्स) और macOS / BSD कार्यान्वयन इसका समर्थन करते हैं।
निम्न उदाहरण:
time xargs -P 3 -I {} sh -c 'eval "$1"' - {} <<'EOF'
sleep 1; echo 1
sleep 2; echo 2
sleep 3; echo 3
echo 4
EOFआउटपुट कुछ इस तरह दिखता है:
1 # output from 1st command
4 # output from *last* command, which started as soon as the count dropped below 3
2 # output from 2nd command
3 # output from 3rd command
real 0m3.012s
user 0m0.011s
sys 0m0.008sसमय से पता चलता है कि कमांड समानांतर में चलाए गए थे (अंतिम आदेश मूल 3 के पहले समाप्त होने के बाद ही लॉन्च किया गया था, लेकिन इसे बहुत जल्दी निष्पादित किया गया था)।
xargsजब तक सभी कमांड्स समाप्त नहीं हो जाती हैं, तब तक यह कमांड अपने आप नहीं लौटेगी, लेकिन आप बैकग्राउंड में इसे कंट्रोल ऑपरेटर के साथ समाप्त करके निष्पादित कर सकते हैं &और फिर waitबिलिन का उपयोग करके पूरी xargsकमांड के समाप्त होने तक प्रतीक्षा कर सकते हैं।
{
xargs -P 3 -I {} sh -c 'eval "$1"' - {} <<'EOF'
sleep 1; echo 1
sleep 2; echo 2
sleep 3; echo 3
echo 4
EOF
} &
# Script execution continues here while `xargs` is running
# in the background.
echo "Waiting for commands to finish..."
# Wait for `xargs` to finish, via special variable $!, which contains
# the PID of the most recently started background process.
wait $!ध्यान दें:
बीएसडी / मैकओएस xargsको आपको स्पष्ट रूप से समानांतर में चलने के लिए कमांड की गिनती निर्दिष्ट करने की आवश्यकता होती है , जबकि जीएनयू xargsआपको समानांतर में यथासंभव-P 0 अधिक चलाने की अनुमति देता है ।
समानांतर में चलने वाली प्रक्रियाओं से आउटपुट उत्पन्न होता है क्योंकि यह उत्पन्न होता है , इसलिए यह अप्रत्याशित रूप से अंतःशिरा होगा ।
parallel, के रूप में में उल्लेख किया ओले के जवाब (करता नहीं सबसे प्लेटफार्मों के साथ मानक आते हैं), आसानी से serializes (समूह) एक प्रति प्रक्रिया आधार और प्रस्तावों के कई और अधिक उन्नत सुविधाओं पर उत्पादन।#!/bin/bash
prog1 & 2> .errorprog1.log; prog2 & 2> .errorprog2.logलॉग को अलग करने के लिए त्रुटियों को पुनर्निर्देशित करें।
prog1 2> .errorprog1.log & prog2 2> .errorprog2.log &
ls notthere1 & 2> .errorprog1.log; ls notthere2 & 2>.errorprog2.log। त्रुटियाँ कंसोल पर जाती हैं, और दोनों त्रुटि फ़ाइलें खाली हैं। जैसा कि @ डेनिस विलियमसन कहते हैं, &एक विभाजक है, जैसे ;, इसलिए (ए) इसे कमांड के अंत में (किसी पुनर्निर्देशन के बाद) जाने की आवश्यकता है, और (बी) आपको बिल्कुल भी ज़रूरत नहीं है ;:-)
एक बहुत ही उपयोगी प्रोग्राम है, जिसे nohup कहते हैं।
nohup - run a command immune to hangups, with output to a non-ttynohupअपने आप में पृष्ठभूमि में कुछ भी नहीं चलता है, और उपयोग nohupकरना पृष्ठभूमि में कार्य चलाने के लिए कोई आवश्यकता या शर्त नहीं है। वे अक्सर एक साथ उपयोगी होते हैं लेकिन जैसे, यह सवाल का जवाब नहीं देता है।
यहाँ एक फ़ंक्शन है जो मैं समानांतर में अधिकतम n प्रक्रिया पर चलाने के लिए उपयोग करता हूं (उदाहरण में n = 4):
max_children=4
function parallel {
local time1=$(date +"%H:%M:%S")
local time2=""
# for the sake of the example, I'm using $2 as a description, you may be interested in other description
echo "starting $2 ($time1)..."
"$@" && time2=$(date +"%H:%M:%S") && echo "finishing $2 ($time1 -- $time2)..." &
local my_pid=$$
local children=$(ps -eo ppid | grep -w $my_pid | wc -w)
children=$((children-1))
if [[ $children -ge $max_children ]]; then
wait -n
fi
}
parallel sleep 5
parallel sleep 6
parallel sleep 7
parallel sleep 8
parallel sleep 9
waitयदि max_children को कोर की संख्या पर सेट किया जाता है, तो यह फ़ंक्शन निष्क्रिय कोर से बचने का प्रयास करेगा।
wait -nको bash4.3+ की आवश्यकता है और यह किसी भी निर्दिष्ट / निहित प्रक्रिया को समाप्त करने के लिए प्रतीक्षा करने के लिए तर्क को बदल देता है ।
मेरे पास हाल ही में ऐसी ही स्थिति थी जहां मुझे एक ही समय में कई कार्यक्रम चलाने की जरूरत थी, लॉग फाइल को अलग करने के लिए अपने आउटपुट को रीडायरेक्ट करें और उनके खत्म होने का इंतजार करें और मैं कुछ इस तरह समाप्त हुआ:
#!/bin/bash
# Add the full path processes to run to the array
PROCESSES_TO_RUN=("/home/joao/Code/test/prog_1/prog1" \
"/home/joao/Code/test/prog_2/prog2")
# You can keep adding processes to the array...
for i in ${PROCESSES_TO_RUN[@]}; do
${i%/*}/./${i##*/} > ${i}.log 2>&1 &
# ${i%/*} -> Get folder name until the /
# ${i##*/} -> Get the filename after the /
done
# Wait for the processes to finish
waitस्रोत: http://joaoperibeiro.com/execute-multiple-programs-and-redirect-their-outputs-linux/
प्रक्रिया Spawning प्रबंधक
निश्चित रूप से, तकनीकी रूप से ये प्रक्रियाएं हैं, और इस कार्यक्रम को वास्तव में एक प्रक्रिया स्पॉइंग मैनेजर कहा जाना चाहिए, लेकिन यह केवल उस तरीके के कारण है जब BASH काम करता है जब यह एम्परसेंड का उपयोग करके कांटे लगाता है, यह कांटा () या शायद क्लोन () सिस्टम कॉल का उपयोग करता है जो कि अलग-अलग मेमोरी स्पेस में क्लोन करता है, बजाय इसके कि pthread_create () की तरह कुछ है जो मेमोरी साझा करेगा। यदि BASH ने बाद का समर्थन किया, तो प्रत्येक "निष्पादन का अनुक्रम" बस एक ही काम करेगा और इसे अधिक कुशल मेमोरी फ़ुटप्रिंट प्राप्त करने के लिए पारंपरिक धागे कहा जा सकता है। कार्यात्मक रूप से यह समान रूप से काम करता है, हालाँकि GLOBAL चर प्रत्येक कार्यकर्ता क्लोन में उपलब्ध नहीं हैं, इसलिए अंतर-प्रक्रिया संचार फ़ाइल का उपयोग और महत्वपूर्ण वर्गों को प्रबंधित करने के लिए अल्पविकसित झुंड semaphore का उपयोग करना मुश्किल है। BASH से कोर्स करना यहां मूल जवाब है, लेकिन मुझे ऐसा लगता है जैसे लोग जानते हैं कि लेकिन वास्तव में यह प्रबंधित करना चाहते हैं कि केवल कांटा लगाने की बजाय जो पैदा हुआ है उसे भूल जाएं। यह एक एकल संसाधन तक पहुँचने के लिए कांटे की प्रक्रियाओं के 200 उदाहरणों को प्रबंधित करने का एक तरीका प्रदर्शित करता है। स्पष्ट रूप से यह ओवरकिल है लेकिन मुझे इसे लिखने में बहुत मज़ा आया इसलिए मैंने इसे जारी रखा। तदनुसार अपने टर्मिनल का आकार बढ़ाएं। मुझे उम्मीद है कि आपको यह काम का लगेगा।
ME=$(basename $0)
IPC="/tmp/$ME.ipc" #interprocess communication file (global thread accounting stats)
DBG=/tmp/$ME.log
echo 0 > $IPC #initalize counter
F1=thread
SPAWNED=0
COMPLETE=0
SPAWN=1000 #number of jobs to process
SPEEDFACTOR=1 #dynamically compensates for execution time
THREADLIMIT=50 #maximum concurrent threads
TPS=1 #threads per second delay
THREADCOUNT=0 #number of running threads
SCALE="scale=5" #controls bc's precision
START=$(date +%s) #whence we began
MAXTHREADDUR=6 #maximum thread life span - demo mode
LOWER=$[$THREADLIMIT*100*90/10000] #90% worker utilization threshold
UPPER=$[$THREADLIMIT*100*95/10000] #95% worker utilization threshold
DELTA=10 #initial percent speed change
threadspeed() #dynamically adjust spawn rate based on worker utilization
{
#vaguely assumes thread execution average will be consistent
THREADCOUNT=$(threadcount)
if [ $THREADCOUNT -ge $LOWER ] && [ $THREADCOUNT -le $UPPER ] ;then
echo SPEED HOLD >> $DBG
return
elif [ $THREADCOUNT -lt $LOWER ] ;then
#if maxthread is free speed up
SPEEDFACTOR=$(echo "$SCALE;$SPEEDFACTOR*(1-($DELTA/100))"|bc)
echo SPEED UP $DELTA%>> $DBG
elif [ $THREADCOUNT -gt $UPPER ];then
#if maxthread is active then slow down
SPEEDFACTOR=$(echo "$SCALE;$SPEEDFACTOR*(1+($DELTA/100))"|bc)
DELTA=1 #begin fine grain control
echo SLOW DOWN $DELTA%>> $DBG
fi
echo SPEEDFACTOR $SPEEDFACTOR >> $DBG
#average thread duration (total elapsed time / number of threads completed)
#if threads completed is zero (less than 100), default to maxdelay/2 maxthreads
COMPLETE=$(cat $IPC)
if [ -z $COMPLETE ];then
echo BAD IPC READ ============================================== >> $DBG
return
fi
#echo Threads COMPLETE $COMPLETE >> $DBG
if [ $COMPLETE -lt 100 ];then
AVGTHREAD=$(echo "$SCALE;$MAXTHREADDUR/2"|bc)
else
ELAPSED=$[$(date +%s)-$START]
#echo Elapsed Time $ELAPSED >> $DBG
AVGTHREAD=$(echo "$SCALE;$ELAPSED/$COMPLETE*$THREADLIMIT"|bc)
fi
echo AVGTHREAD Duration is $AVGTHREAD >> $DBG
#calculate timing to achieve spawning each workers fast enough
# to utilize threadlimit - average time it takes to complete one thread / max number of threads
TPS=$(echo "$SCALE;($AVGTHREAD/$THREADLIMIT)*$SPEEDFACTOR"|bc)
#TPS=$(echo "$SCALE;$AVGTHREAD/$THREADLIMIT"|bc) # maintains pretty good
#echo TPS $TPS >> $DBG
}
function plot()
{
echo -en \\033[${2}\;${1}H
if [ -n "$3" ];then
if [[ $4 = "good" ]];then
echo -en "\\033[1;32m"
elif [[ $4 = "warn" ]];then
echo -en "\\033[1;33m"
elif [[ $4 = "fail" ]];then
echo -en "\\033[1;31m"
elif [[ $4 = "crit" ]];then
echo -en "\\033[1;31;4m"
fi
fi
echo -n "$3"
echo -en "\\033[0;39m"
}
trackthread() #displays thread status
{
WORKERID=$1
THREADID=$2
ACTION=$3 #setactive | setfree | update
AGE=$4
TS=$(date +%s)
COL=$[(($WORKERID-1)/50)*40]
ROW=$[(($WORKERID-1)%50)+1]
case $ACTION in
"setactive" )
touch /tmp/$ME.$F1$WORKERID #redundant - see main loop
#echo created file $ME.$F1$WORKERID >> $DBG
plot $COL $ROW "Worker$WORKERID: ACTIVE-TID:$THREADID INIT " good
;;
"update" )
plot $COL $ROW "Worker$WORKERID: ACTIVE-TID:$THREADID AGE:$AGE" warn
;;
"setfree" )
plot $COL $ROW "Worker$WORKERID: FREE " fail
rm /tmp/$ME.$F1$WORKERID
;;
* )
;;
esac
}
getfreeworkerid()
{
for i in $(seq 1 $[$THREADLIMIT+1])
do
if [ ! -e /tmp/$ME.$F1$i ];then
#echo "getfreeworkerid returned $i" >> $DBG
break
fi
done
if [ $i -eq $[$THREADLIMIT+1] ];then
#echo "no free threads" >> $DBG
echo 0
#exit
else
echo $i
fi
}
updateIPC()
{
COMPLETE=$(cat $IPC) #read IPC
COMPLETE=$[$COMPLETE+1] #increment IPC
echo $COMPLETE > $IPC #write back to IPC
}
worker()
{
WORKERID=$1
THREADID=$2
#echo "new worker WORKERID:$WORKERID THREADID:$THREADID" >> $DBG
#accessing common terminal requires critical blocking section
(flock -x -w 10 201
trackthread $WORKERID $THREADID setactive
)201>/tmp/$ME.lock
let "RND = $RANDOM % $MAXTHREADDUR +1"
for s in $(seq 1 $RND) #simulate random lifespan
do
sleep 1;
(flock -x -w 10 201
trackthread $WORKERID $THREADID update $s
)201>/tmp/$ME.lock
done
(flock -x -w 10 201
trackthread $WORKERID $THREADID setfree
)201>/tmp/$ME.lock
(flock -x -w 10 201
updateIPC
)201>/tmp/$ME.lock
}
threadcount()
{
TC=$(ls /tmp/$ME.$F1* 2> /dev/null | wc -l)
#echo threadcount is $TC >> $DBG
THREADCOUNT=$TC
echo $TC
}
status()
{
#summary status line
COMPLETE=$(cat $IPC)
plot 1 $[$THREADLIMIT+2] "WORKERS $(threadcount)/$THREADLIMIT SPAWNED $SPAWNED/$SPAWN COMPLETE $COMPLETE/$SPAWN SF=$SPEEDFACTOR TIMING=$TPS"
echo -en '\033[K' #clear to end of line
}
function main()
{
while [ $SPAWNED -lt $SPAWN ]
do
while [ $(threadcount) -lt $THREADLIMIT ] && [ $SPAWNED -lt $SPAWN ]
do
WID=$(getfreeworkerid)
worker $WID $SPAWNED &
touch /tmp/$ME.$F1$WID #if this loops faster than file creation in the worker thread it steps on itself, thread tracking is best in main loop
SPAWNED=$[$SPAWNED+1]
(flock -x -w 10 201
status
)201>/tmp/$ME.lock
sleep $TPS
if ((! $[$SPAWNED%100]));then
#rethink thread timing every 100 threads
threadspeed
fi
done
sleep $TPS
done
while [ "$(threadcount)" -gt 0 ]
do
(flock -x -w 10 201
status
)201>/tmp/$ME.lock
sleep 1;
done
status
}
clear
threadspeed
main
wait
status
echoआपकी स्क्रिप्ट इस तरह दिखनी चाहिए:
prog1 &
prog2 &
.
.
progn &
wait
progn+1 &
progn+2 &
.
.अपने सिस्टम को मानते हुए एक बार में n काम ले सकते हैं। एक समय में केवल n कार्य चलाने के लिए प्रतीक्षा का उपयोग करें।
साथ bashj ( https://sourceforge.net/projects/bashj/ ), आप न केवल कई चलाने के लिए सक्षम होना चाहिए प्रक्रियाओं (वैसे अन्य सुझाव दिया), लेकिन यह भी कई धागे एक JVM अपनी स्क्रिप्ट से नियंत्रित में। लेकिन निश्चित रूप से इसके लिए जावा जेडीके की आवश्यकता है। थ्रेड प्रक्रियाओं की तुलना में कम संसाधन का उपभोग करते हैं।
यहाँ एक काम कोड है:
#!/usr/bin/bashj
#!java
public static int cnt=0;
private static void loop() {u.p("java says cnt= "+(cnt++));u.sleep(1.0);}
public static void startThread()
{(new Thread(() -> {while (true) {loop();}})).start();}
#!bashj
j.startThread()
while [ j.cnt -lt 4 ]
do
echo "bash views cnt=" j.cnt
sleep 0.5
done
wait! हां, बैश में आप स्क्रिप्ट की बाल प्रक्रियाओं का इंतजार कर सकते हैं।