లూప్ కోసం పైథాన్ మల్టీప్రాసెసింగ్

మల్టీప్రాసెసింగ్ మల్టీథ్రెడింగ్‌తో పోల్చవచ్చు. అయినప్పటికీ, థ్రెడింగ్ కోసం ఉపయోగించే GIL కారణంగా మనం ఒక క్షణంలో ఒక థ్రెడ్‌ను మాత్రమే అమలు చేయగలము. మల్టీప్రాసెసింగ్ అనేది అనేక CPU కోర్లలో వరుసగా కార్యకలాపాలను నిర్వహించే ప్రక్రియ. థ్రెడ్‌లను సమాంతరంగా ఆపరేట్ చేయడం సాధ్యం కాదు. అయినప్పటికీ, మల్టీప్రాసెసింగ్ ప్రాసెస్‌లను స్థాపించడానికి మరియు వాటిని వివిధ CPU కోర్లలో ఏకకాలంలో అమలు చేయడానికి అనుమతిస్తుంది. లూప్, ఫర్-లూప్ వంటివి చాలా తరచుగా ఉపయోగించే స్క్రిప్టింగ్ భాషలలో ఒకటి. ముందుగా నిర్ణయించిన పునరావృతాల సంఖ్య వంటి ప్రమాణాన్ని చేరుకునే వరకు వివిధ డేటాను ఉపయోగించి అదే పనిని పునరావృతం చేయండి. లూప్ ప్రతి పునరావృతాన్ని ఒక్కొక్కటిగా పూర్తి చేస్తుంది.

ఉదాహరణ 1:  పైథాన్ మల్టీప్రాసెసింగ్ మాడ్యూల్‌లో ఫర్-లూప్‌ని ఉపయోగించడం

ఈ ఉదాహరణలో, మేము ఫర్-లూప్ మరియు పైథాన్ మల్టీప్రాసెసింగ్ మాడ్యూల్ క్లాస్ ప్రాసెస్‌ని ఉపయోగిస్తాము. మేము చాలా సరళమైన ఉదాహరణతో ప్రారంభిస్తాము, తద్వారా పైథాన్ మల్టీప్రాసెసింగ్ ఫర్-లూప్ ఎలా పనిచేస్తుందో మీరు త్వరగా అర్థం చేసుకోవచ్చు. థ్రెడింగ్ మాడ్యూల్‌తో పోల్చదగిన ఇంటర్‌ఫేస్‌ని ఉపయోగించి, మల్టీప్రాసెసింగ్ ప్రక్రియల సృష్టిని ప్యాక్ చేస్తుంది.

థ్రెడ్‌ల కంటే సబ్-ప్రాసెస్‌లను ఉపయోగించడం ద్వారా, మల్టీప్రాసెసింగ్ ప్యాకేజీ స్థానిక మరియు సుదూర సమ్మేళనాన్ని అందిస్తుంది, తద్వారా గ్లోబల్ ఇంటర్‌ప్రెటర్ లాక్‌ని నివారిస్తుంది. క్రమం ద్వారా నిరంతరం పునరావృతం చేయడానికి, స్ట్రింగ్ ఆబ్జెక్ట్ లేదా టుపుల్ కావచ్చు, ఫోర్-లూప్‌ని ఉపయోగించండి. ఇది ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌లలో కనిపించే కీవర్డ్ లాగా తక్కువ పని చేస్తుంది మరియు ఇతర ప్రోగ్రామింగ్ లాంగ్వేజ్‌లలో కనిపించే ఇటరేటర్ పద్ధతి వలె ఉంటుంది. కొత్త మల్టీప్రాసెసింగ్‌ను ప్రారంభించడం ద్వారా, మీరు ఏకకాలంలో విధానాన్ని అమలు చేసే ఫర్-లూప్‌ను అమలు చేయవచ్చు.

'స్పైడర్' సాధనాన్ని ఉపయోగించడం ద్వారా కోడ్ అమలు కోసం కోడ్‌ను అమలు చేయడం ద్వారా ప్రారంభిద్దాం. పైథాన్‌ను అమలు చేయడానికి 'స్పైడర్' కూడా ఉత్తమమైనదని మేము నమ్ముతున్నాము. మేము కోడ్ అమలులో ఉన్న మల్టీప్రాసెసింగ్ మాడ్యూల్ ప్రాసెస్‌ని దిగుమతి చేస్తాము. 'ప్రాసెస్ క్లాస్' అని పిలవబడే పైథాన్ కాన్సెప్ట్‌లో మల్టీప్రాసెసింగ్ ఒక కొత్త పైథాన్ ప్రాసెస్‌ను సృష్టిస్తుంది, కోడ్‌ని ఎగ్జిక్యూట్ చేయడానికి ఒక పద్ధతిని ఇస్తుంది మరియు పేరెంట్ అప్లికేషన్‌కు ఎగ్జిక్యూషన్‌ని నిర్వహించడానికి ఒక మార్గాన్ని ఇస్తుంది. ప్రాసెస్ క్లాస్ స్టార్ట్() మరియు జాయిన్() విధానాలను కలిగి ఉంటుంది, రెండూ కీలకమైనవి.

తరువాత, మేము 'func' అనే వినియోగదారు నిర్వచించిన ఫంక్షన్‌ని నిర్వచించాము. ఇది వినియోగదారు నిర్వచించిన ఫంక్షన్ కాబట్టి, మేము దీనికి మా ఎంపిక పేరుని ఇస్తాము. ఈ ఫంక్షన్ యొక్క బాడీ లోపల, మేము 'సబ్జెక్ట్' వేరియబుల్‌ను ఆర్గ్యుమెంట్‌గా మరియు 'గణితం' విలువగా పాస్ చేస్తాము. తరువాత, మేము 'ప్రింట్()' ఫంక్షన్‌ని పిలుస్తాము, 'సాధారణ విషయం యొక్క పేరు' అనే ప్రకటనను అలాగే విలువను కలిగి ఉన్న దాని 'విషయం' వాదనను పాస్ చేస్తాము. తరువాత, కింది దశలో, మేము “if name== _main_”ని ఉపయోగిస్తాము, ఇది ఫైల్ మాడ్యూల్‌గా దిగుమతి అయినప్పుడు కోడ్‌ను అమలు చేయకుండా మిమ్మల్ని నిరోధిస్తుంది మరియు కంటెంట్ స్క్రిప్ట్‌గా అమలు చేయబడినప్పుడు మాత్రమే అలా చేయడానికి మిమ్మల్ని అనుమతిస్తుంది.

మీరు ప్రారంభించిన కండిషన్ విభాగం చాలా సందర్భాలలో మీ ఫైల్ స్క్రిప్ట్‌గా రన్ అయినప్పుడు మాత్రమే ఎగ్జిక్యూట్ చేయబడే కంటెంట్‌ను అందించే లొకేషన్‌గా భావించబడవచ్చు. అప్పుడు, మేము ఆర్గ్యుమెంట్ సబ్జెక్ట్‌ని ఉపయోగిస్తాము మరియు దానిలో “సైన్స్”, “ఇంగ్లీష్” మరియు “కంప్యూటర్” అనే కొన్ని విలువలను నిల్వ చేస్తాము. ఈ ప్రక్రియకు కింది దశలో “ప్రాసెస్1[]” అనే పేరు ఇవ్వబడుతుంది. అప్పుడు, మేము ప్రాసెస్‌లోని ఫంక్షన్‌ను కాల్ చేయడానికి “ప్రాసెస్(టార్గెట్=ఫంక్)”ని ఉపయోగిస్తాము. ఫంక్షన్‌కు కాల్ చేయడానికి టార్గెట్ ఉపయోగించబడుతుంది మరియు మేము ఈ ప్రక్రియను “P” వేరియబుల్‌లో సేవ్ చేస్తాము.

తరువాత, “func” ఫంక్షన్‌లో మనకు ఉన్న జాబితా చివరకి ఒక అంశాన్ని జోడించే “append()” ఫంక్షన్‌ని కాల్ చేయడానికి “process1”ని ఉపయోగిస్తాము. ప్రక్రియ “P” వేరియబుల్‌లో నిల్వ చేయబడినందున, మేము ఈ ఫంక్షన్‌కు “P”ని దాని వాదనగా పాస్ చేస్తాము. చివరగా, మేము ప్రక్రియను ప్రారంభించడానికి 'P'తో 'ప్రారంభం()' ఫంక్షన్‌ని ఉపయోగిస్తాము. ఆ తర్వాత, “సబ్జెక్ట్” ఆర్గ్యుమెంట్‌ని సరఫరా చేస్తున్నప్పుడు మేము పద్ధతిని మళ్లీ అమలు చేస్తాము మరియు సబ్జెక్ట్‌లో “ఫర్” ఉపయోగిస్తాము. అప్పుడు, 'process1' మరియు 'add()' పద్ధతిని మరోసారి ఉపయోగించి, మేము ప్రక్రియను ప్రారంభిస్తాము. ప్రక్రియ అమలు అవుతుంది మరియు అవుట్‌పుట్ తిరిగి వస్తుంది. 'జాయిన్()' టెక్నిక్‌ని ఉపయోగించి ప్రక్రియ ముగించమని చెప్పబడింది. “జాయిన్()” విధానాన్ని పిలవని ప్రక్రియలు నిష్క్రమించవు. ఒక కీలకమైన అంశం ఏమిటంటే, మీరు ప్రక్రియ ద్వారా ఏవైనా వాదనలను అందించాలనుకుంటే “args” కీవర్డ్ పరామితిని తప్పనిసరిగా ఉపయోగించాలి.

ఇప్పుడు, మేము 'func' ఫంక్షన్‌లోకి పాస్ చేసే “maths” సబ్జెక్ట్‌కి సంబంధించిన విలువను పాస్ చేయడం ద్వారా స్టేట్‌మెంట్ మొదట ప్రదర్శించబడుతుందని మీరు అవుట్‌పుట్‌లో చూడవచ్చు, ఎందుకంటే మేము దీన్ని మొదట “ప్రాసెస్” ఫంక్షన్‌ని ఉపయోగించి పిలుస్తాము. అప్పుడు, చివరలో జోడించబడిన జాబితాలో ఇప్పటికే ఉన్న విలువలను కలిగి ఉండటానికి మేము “append()” ఆదేశాన్ని ఉపయోగిస్తాము. అప్పుడు, 'సైన్స్', 'కంప్యూటర్' మరియు 'ఇంగ్లీష్' ప్రదర్శించబడ్డాయి. కానీ, మీరు గమనిస్తే, విలువలు సరైన క్రమంలో లేవు. ఎందుకంటే ప్రక్రియ పూర్తయిన వెంటనే వారు అలా చేస్తారు మరియు వారి సందేశాన్ని నివేదించారు.

ఉదాహరణ 2: సీక్వెన్షియల్ ఫర్-లూప్‌ని మల్టీప్రాసెసింగ్ పారలల్ ఫర్-లూప్‌గా మార్చడం

ఈ ఉదాహరణలో, మల్టీప్రాసెసింగ్ లూప్ టాస్క్ సమాంతరంగా లూప్ టాస్క్‌గా మార్చబడటానికి ముందు వరుసగా అమలు చేయబడుతుంది. మీరు లూప్‌లను ఉపయోగించి జరిగే క్రమంలో సేకరణ లేదా స్ట్రింగ్ వంటి సీక్వెన్స్‌ల ద్వారా చక్రం తిప్పవచ్చు.

ఇప్పుడు, కోడ్‌ని అమలు చేయడం ప్రారంభిద్దాం. ముందుగా, మేము టైమ్ మాడ్యూల్ నుండి 'నిద్ర'ని దిగుమతి చేస్తాము. టైమ్ మాడ్యూల్‌లోని “స్లీప్()” విధానాన్ని ఉపయోగించి, మీరు కోరుకున్నంత కాలం కాలింగ్ థ్రెడ్ అమలును తాత్కాలికంగా నిలిపివేయవచ్చు. అప్పుడు, మేము యాదృచ్ఛిక మాడ్యూల్ నుండి 'యాదృచ్ఛికం' ఉపయోగిస్తాము, 'func' పేరుతో ఒక ఫంక్షన్‌ను నిర్వచించి, 'argu' అనే కీవర్డ్‌ను పాస్ చేస్తాము. అప్పుడు, మేము 'val' ఉపయోగించి యాదృచ్ఛిక విలువను సృష్టించి, దానిని 'యాదృచ్ఛికం' గా సెట్ చేస్తాము. అప్పుడు, మేము “స్లీప్()” పద్ధతిని ఉపయోగించి కొంత కాలం పాటు బ్లాక్ చేస్తాము మరియు “val”ని పారామీటర్‌గా పాస్ చేస్తాము. అప్పుడు, సందేశాన్ని ప్రసారం చేయడానికి, మేము 'ప్రింట్ ()' పద్ధతిని అమలు చేస్తాము, 'సిద్ధంగా' మరియు 'arg' అనే కీవర్డ్‌ను దాని పరామితిగా పాస్ చేస్తాము, అలాగే 'సృష్టించబడింది' మరియు 'val'ని ఉపయోగించి విలువను పాస్ చేస్తాము.

చివరగా, మేము 'ఫ్లష్' ను ఉపయోగించుకుంటాము మరియు దానిని 'ట్రూ' గా సెట్ చేస్తాము. పైథాన్ ప్రింట్ ఫంక్షన్‌లోని ఫ్లష్ ఎంపికను ఉపయోగించి అవుట్‌పుట్‌ను బఫర్ చేయాలా వద్దా అని వినియోగదారు నిర్ణయించుకోవచ్చు. ఫాల్స్ యొక్క ఈ పరామితి యొక్క డిఫాల్ట్ విలువ అవుట్‌పుట్ బఫర్ చేయబడదని సూచిస్తుంది. మీరు దీన్ని ఒప్పుకు సెట్ చేస్తే అవుట్‌పుట్ ఒకదానికొకటి అనుసరించే పంక్తుల శ్రేణిగా ప్రదర్శించబడుతుంది. అప్పుడు, మేము ఎంట్రీ పాయింట్లను భద్రపరచడానికి “if name== main”ని ఉపయోగిస్తాము. తరువాత, మేము పనిని వరుసగా అమలు చేస్తాము. ఇక్కడ, మేము పరిధిని '10'కి సెట్ చేసాము అంటే లూప్ 10 పునరావృతాల తర్వాత ముగుస్తుంది. తరువాత, మేము “ప్రింట్()” ఫంక్షన్‌ని పిలుస్తాము, దానిని “సిద్ధంగా” ఇన్‌పుట్ స్టేట్‌మెంట్‌ను పాస్ చేసి, “ఫ్లష్=ట్రూ” ఎంపికను ఉపయోగిస్తాము.

మేము కోడ్‌ను అమలు చేసినప్పుడు, లూప్ ఫంక్షన్‌ను “10” సార్లు అమలు చేయడానికి కారణమవుతుందని మీరు ఇప్పుడు చూడవచ్చు. ఇది 10 సార్లు పునరావృతమవుతుంది, ఇండెక్స్ సున్నా వద్ద ప్రారంభమై ఇండెక్స్ తొమ్మిది వద్ద ముగుస్తుంది. ప్రతి సందేశం టాస్క్ నంబర్‌ను కలిగి ఉంటుంది, ఇది మనం 'ఆర్గ్' మరియు సృష్టి సంఖ్యగా పాస్ చేసే ఫంక్షన్ నంబర్.

ఈ సీక్వెన్షియల్ లూప్ ఇప్పుడు మల్టీప్రాసెసింగ్ పారలల్ ఫర్-లూప్‌గా రూపాంతరం చెందుతోంది. మేము అదే కోడ్‌ని ఉపయోగిస్తాము, అయితే మేము మల్టీప్రాసెసింగ్ కోసం కొన్ని అదనపు లైబ్రరీలు మరియు ఫంక్షన్‌లకు వెళ్తున్నాము. కాబట్టి, మనం ముందుగా వివరించిన విధంగానే, మల్టీప్రాసెసింగ్ నుండి ప్రక్రియను తప్పనిసరిగా దిగుమతి చేసుకోవాలి. తరువాత, మేము 'func' అనే ఫంక్షన్‌ని సృష్టించి, యాదృచ్ఛిక సంఖ్యను పొందడానికి 'val=random'ని ఉపయోగించే ముందు 'arg' అనే కీవర్డ్‌ని పాస్ చేస్తాము.

తర్వాత, సందేశాన్ని చూపించడానికి “print()” పద్ధతిని ప్రారంభించిన తర్వాత మరియు కొంచెం వ్యవధిని ఆలస్యం చేయడానికి “val” పరామితిని ఇచ్చిన తర్వాత, మేము ఎంట్రీ పాయింట్‌లను భద్రపరచడానికి “if name= main” ఫంక్షన్‌ని ఉపయోగిస్తాము. ఆ తర్వాత, మేము ఒక ప్రాసెస్‌ని సృష్టించి, 'ప్రాసెస్'ని ఉపయోగించి ప్రాసెస్‌లో ఫంక్షన్‌ని కాల్ చేస్తాము మరియు 'టార్గెట్=ఫంక్'ని పాస్ చేస్తాము. అప్పుడు, మేము 'func', 'arg'ని పాస్ చేస్తాము, 'm' విలువను పాస్ చేస్తాము మరియు '10' శ్రేణిని పాస్ చేస్తాము అంటే లూప్ '10' పునరావృతాల తర్వాత ఫంక్షన్‌ను ముగించిందని అర్థం. అప్పుడు, మేము 'ప్రాసెస్' తో 'ప్రారంభ ()' పద్ధతిని ఉపయోగించి ప్రక్రియను ప్రారంభిస్తాము. అప్పుడు, మేము ప్రక్రియ అమలు కోసం వేచి ఉండటానికి మరియు ఆ తర్వాత అన్ని ప్రక్రియలను పూర్తి చేయడానికి “జాయిన్()” పద్ధతిని పిలుస్తాము.

అందువల్ల, మేము కోడ్‌ను అమలు చేసినప్పుడు, విధులు ప్రధాన ప్రక్రియను పిలుస్తాయి మరియు వాటి అమలును ప్రారంభిస్తాయి. అయినప్పటికీ, అన్ని పనులు పూర్తయ్యే వరకు అవి పూర్తి చేయబడతాయి. ప్రతి పని ఏకకాలంలో నిర్వహించబడటం వలన మనం దానిని చూడవచ్చు. ఇది పూర్తయిన వెంటనే దాని సందేశాన్ని నివేదిస్తుంది. దీనర్థం, సందేశాలు క్రమంలో లేనప్పటికీ, అన్ని “10” పునరావృత్తులు పూర్తయిన తర్వాత లూప్ ముగుస్తుంది.

ముగింపు

మేము ఈ వ్యాసంలో పైథాన్ మల్టీప్రాసెసింగ్ ఫర్-లూప్ గురించి కవర్ చేసాము. మేము రెండు దృష్టాంతాలను కూడా అందించాము. పైథాన్ లూప్ మల్టీప్రాసెసింగ్ లైబ్రరీలో ఫర్-లూప్‌ని ఎలా ఉపయోగించాలో మొదటి ఉదాహరణ చూపిస్తుంది. మరియు రెండవ దృష్టాంతంలో సీక్వెన్షియల్ ఫర్-లూప్‌ను సమాంతర మల్టీప్రాసెసింగ్ ఫర్-లూప్‌గా ఎలా మార్చాలో చూపుతుంది. పైథాన్ మల్టీప్రాసెసింగ్ కోసం స్క్రిప్ట్‌ను నిర్మించే ముందు, మనం తప్పనిసరిగా మల్టీప్రాసెసింగ్ మాడ్యూల్‌ను దిగుమతి చేసుకోవాలి.