సమాంతర ఉద్యోగాలకు భిన్నమైన ఉదాహరణలు
'ఫర్' లూప్‌ని ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేసే వివిధ మార్గాలు ట్యుటోరియల్‌లోని ఈ భాగంలో చూపబడ్డాయి.
ఉదాహరణ 1: 'ఫర్' లూప్‌ని ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేయండి
బాష్ స్క్రిప్ట్‌లో సమాంతర జాబ్‌లను నిర్వహించడానికి 'ఫర్' లూప్‌ని ఉపయోగించడం చాలా సులభమైన మార్గం. 'ఫర్' లూప్‌ను 10000 సార్లు అమలు చేసే క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి మరియు 1000 సార్లు పునరావృతం చేసిన తర్వాత సంఖ్యను ప్రింట్ చేయండి. ఈ పని 'ఫర్' లూప్ ఉపయోగించి సమాంతరంగా జరుగుతుంది.
#!/బిన్/బాష్
#10000కి చేరుకునే వరకు లూప్‌ను పునరావృతం చేయండి
కోసం విలువ లో ` సీక్ 0 1000 10000 ` ;
చేయండి
#ప్రతి 1000వ సంఖ్యను ప్రింట్ చేయండి
ప్రతిధ్వని $val
పూర్తి
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. అవుట్‌పుట్‌లో ముద్రించబడిన 0 మరియు 10000 మధ్య 10 సంఖ్యలు ఉన్నాయి:
ఉదాహరణ 2: నెస్టెడ్ 'ఫర్' లూప్‌ని ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేయండి
'A' నుండి 'C' వరకు అక్షర అక్షరాలు మరియు 1 నుండి 3 సంఖ్యలను ఉపయోగించి క్రమ సంఖ్యను రూపొందించే సమూహ 'కోసం' లూప్‌ని అమలు చేసే క్రింది స్క్రిప్ట్‌తో Bash ఫైల్‌ను సృష్టించండి. ఔటర్ లూప్ యొక్క మొదటి పునరావృతంలో మరియు తర్వాత అంతర్గత లూప్ యొక్క పునరావృతాన్ని పూర్తి చేయడం, “A1. CodeIgniter”, “A2. లారావెల్”, మరియు “A3. కేక్‌పిహెచ్‌పి” అని ముద్రించబడ్డాయి. బాహ్య లూప్ యొక్క రెండవ పునరావృతంలో మరియు లోపలి లూప్ యొక్క పునరావృతాన్ని పూర్తి చేసిన తర్వాత, “B1. ఒరాకిల్', 'B2. MySQL', మరియు 'B3. SQL” ముద్రించబడ్డాయి. బాహ్య లూప్ యొక్క మూడవ పునరావృతంలో మరియు అంతర్గత లూప్ యొక్క పునరావృతాన్ని పూర్తి చేసిన తర్వాత, “C1. CSS', 'C2. J క్వెరీ”, మరియు “C3. జావాస్క్రిప్ట్” ముద్రించబడ్డాయి.
#అవుటర్ లూప్
కోసం ఆల్ఫా లో { ఎ.సి }
చేయండి
#ఇన్నర్ లూప్
కోసం సంఖ్య లో { 1 .. 3 }
చేయండి
#కండీషన్ ఆధారంగా అవుట్‌పుట్‌ను ప్రింట్ చేయండి
ఉంటే [ $ఆల్ఫా == 'ఎ' ] ; అప్పుడు
శ్రేణి జాబితా = ( 'కోడ్ ఇగ్నైటర్' 'లారావెల్' 'కేక్PHP' )
ఎలిఫ్ [ $ఆల్ఫా == 'బి' ] ; అప్పుడు
శ్రేణి జాబితా = ( 'ఒరాకిల్' 'MySQL' 'SQL' )
ఎలిఫ్ [ $ఆల్ఫా == 'సి' ] ; అప్పుడు
శ్రేణి జాబితా = ( 'CSS' 'J క్వెరీ' 'జావాస్క్రిప్ట్' )
ఉంటుంది
ప్రతిధ్వని ' $ఆల్ఫా $సంఖ్య . ${arrayList[$number-1]} '
పూర్తి
పూర్తి
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది:
ఉదాహరణ 3: 'ఫర్' లూప్ మరియు 'వెయిట్' కమాండ్ ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేయండి
'వెయిట్' కమాండ్ అనేది బాష్ యొక్క చాలా ఉపయోగకరమైన కమాండ్, ఇది బహుళ జాబ్‌లు నడుస్తున్నప్పుడు ఒక పనిని పూర్తి చేయడానికి వేచి ఉండటానికి ఉపయోగించబడుతుంది. తక్కువ జాబ్‌లు నడుస్తున్నట్లయితే, 'వేచి ఉండండి' కమాండ్ కొత్త జాబ్‌ను అసమకాలికంగా ప్రారంభిస్తుంది. సమూహ 'కోసం' లూప్‌లో బ్యాక్‌గ్రౌండ్ జాబ్‌ని అమలు చేసే క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. అన్ని చైల్డ్ ప్రాసెస్‌లను పూర్తి చేయడానికి వేచి ఉండటానికి “వేచి ఉండండి” ఆదేశం ఉపయోగించబడుతుంది. బ్యాక్‌గ్రౌండ్ ప్రాసెస్‌గా “తేదీ” మరియు “స్లీప్” కమాండ్‌లు అమలు చేయబడతాయి.
#అవుటర్ లూప్కోసం i లో { 1 .. 2 }
చేయండి
#ఇన్నర్ లూప్
కోసం జె లో { 1 .. 3 }
చేయండి
ఉంటే పరీక్ష ' $(ఉద్యోగాలు | wc -l) ' -ge 2 ; అప్పుడు
వేచి ఉండండి -ఎన్
ఉంటుంది
#నేపథ్య ప్రక్రియ
{
తేదీ
నిద్ర 1
} &
పూర్తి
పూర్తి
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. సమూహ 'కోసం' లూప్‌లను 2×3=6 సార్లు పునరావృతం చేయడానికి నేపథ్య ప్రక్రియ నుండి ప్రస్తుత తేదీ మరియు సమయం 6 సార్లు ముద్రించబడతాయి:
ఉదాహరణ 4: సీక్వెన్షియల్ మరియు పారలల్ రన్‌ల మధ్య తేడాలు
సీక్వెన్షియల్ రన్ మరియు సమాంతర రన్ మధ్య తేడాలను చూపించే క్రింది స్క్రిప్ట్‌తో బాష్ ఫైల్‌ను సృష్టించండి. prn_char() ఫంక్షన్ 0.5 సెకన్ల వ్యవధితో ఐదు అక్షరాలను ప్రింట్ చేయడానికి స్క్రిప్ట్‌లో నిర్వచించబడింది. తరువాత, prn_char() ఫంక్షన్‌ను వరుసగా అమలు చేయడానికి మొదటి “ఫర్” లూప్ ఉపయోగించబడుతుంది. రెండవ “ఫర్” లూప్ prn_char() ఫంక్షన్‌ను సమాంతరంగా అమలు చేయడానికి ఉపయోగించబడుతుంది.
#0.5 సెకన్ల వ్యవధితో 5 అక్షరాలను ప్రింట్ చేయడానికి ఒక ఫంక్షన్‌ను నిర్వచించండిprn_char ( ) {
కోసం సి లో హలో; చేయండి
నిద్ర 0.5 ;
ప్రతిధ్వని -ఎన్ $సి ;
పూర్తి
ప్రతిధ్వని
}
# లూప్‌ని ఉపయోగించి వరుసగా ఫంక్షన్‌ని అమలు చేయండి
కోసం బయటకు లో { 1 .. 3 } ; చేయండి
prn_char ' $అవుట్ '
పూర్తి
# సమాంతరంగా లూప్ కోసం ఉపయోగించి ఫంక్షన్‌ని అమలు చేయండి
కోసం బయటకు లో { 1 .. 3 } ; చేయండి
prn_char ' $అవుట్ ' &
పూర్తి
స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత క్రింది అవుట్‌పుట్ కనిపిస్తుంది. సీక్వెన్షియల్ రన్ మరియు సమాంతర పరుగు మధ్య వ్యత్యాసం అవుట్‌పుట్‌లో చూపబడింది. ఇక్కడ, prn_char() ఫంక్షన్ యొక్క “ఫర్” లూప్ యొక్క అన్ని అక్షరాలు సీక్వెన్షియల్ రన్‌లో ఒకేసారి ముద్రించబడతాయి మరియు ప్రతి అక్షరం సమాంతర రన్‌లో మూడుసార్లు ముద్రించబడుతుంది:
ముగింపు
అనేక ప్రోగ్రామింగ్ ప్రయోజనాల కోసం 'ఫర్' లూప్‌ని ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేయడం అవసరం. 'ఫర్' లూప్‌ని ఉపయోగించి సమాంతర ఉద్యోగాలను అమలు చేసే పద్ధతులు ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి.