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

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

ఉదాహరణ 1: పైథాన్‌లో మల్టీప్రాసెసింగ్ క్యూను సృష్టించడానికి క్యూ() పద్ధతిని ఉపయోగించడం

ఈ ఉదాహరణలో, మేము “క్యూ()” పద్ధతిని ఉపయోగించి పైథాన్‌లో మల్టీప్రాసెసింగ్ క్యూను సృష్టిస్తాము. మల్టీప్రాసెసింగ్ అనేది రెండు లేదా అంతకంటే ఎక్కువ ప్రక్రియలను ఏకకాలంలో నిర్వహించడానికి సిస్టమ్‌లో ఒకటి లేదా అంతకంటే ఎక్కువ CPUల వినియోగాన్ని సూచిస్తుంది. మల్టీప్రాసెసింగ్, పైథాన్‌లో నిర్మించిన మాడ్యూల్, ప్రక్రియల మధ్య మారడాన్ని సులభతరం చేస్తుంది. మల్టీప్రాసెసింగ్‌తో పని చేసే ముందు ప్రాసెస్ ప్రాపర్టీ గురించి మనకు తెలిసి ఉండాలి. డేటా మోడల్‌లో క్యూ కీలకమైన అంశం అని మాకు తెలుసు. 'ఫస్ట్-ఇన్-ఫస్ట్-అవుట్' ఆలోచనపై నిర్మించబడిన ప్రామాణిక డేటా క్యూ మరియు పైథాన్ మల్టీప్రాసెసింగ్ ఖచ్చితమైన ప్రతిరూపాలు. సాధారణంగా, క్యూ పైథాన్ ఆబ్జెక్ట్‌ను నిల్వ చేస్తుంది మరియు టాస్క్‌ల మధ్య డేటా బదిలీకి కీలకం.

పైథాన్ స్క్రిప్ట్‌ను అమలు చేయడానికి “స్పైడర్” సాధనం ఉపయోగించబడుతుంది, కాబట్టి ఇప్పుడు ప్రారంభిద్దాం. మనం పైథాన్ మల్టీప్రాసెసింగ్ స్క్రిప్ట్‌ని అమలు చేస్తున్నందున ముందుగా మల్టీప్రాసెసింగ్ మాడ్యూల్‌ని దిగుమతి చేసుకోవాలి. మల్టీప్రాసెసింగ్ మాడ్యూల్‌ను “m”గా దిగుమతి చేయడం ద్వారా మేము దీన్ని చేసాము. “m.queue()” టెక్నిక్‌ని ఉపయోగించి, మేము మల్టీప్రాసెసింగ్ “క్యూ()” పద్ధతిని అమలు చేస్తాము. ఇక్కడ, మనం “క్యూ” అనే వేరియబుల్‌ని సృష్టించి, దానిలో మల్టీప్రాసెసింగ్ “క్యూ()” పద్ధతిని ఉంచుతాము. క్యూ ఐటెమ్‌లను 'ఫస్ట్-ఇన్, ఫస్ట్-అవుట్' ఆర్డర్‌లో స్టోర్ చేస్తుందని మాకు తెలుసు, మనం మొదట జోడించిన అంశం మొదట తీసివేయబడుతుంది. మల్టీప్రాసెసింగ్ క్యూను ప్రారంభించిన తర్వాత, మేము 'ప్రింట్()' పద్ధతిని పిలుస్తాము, 'మల్టీప్రాసెసింగ్ క్యూ ఉంది' అనే ప్రకటనను స్క్రీన్‌పై ప్రదర్శించడానికి దాని వాదనగా పాస్ చేస్తాము. అప్పుడు, మేము ఈ వేరియబుల్‌లో నిర్మించిన క్యూను నిల్వ చేసినందున, “ప్రింట్()” పద్ధతి యొక్క కుండలీకరణంలో “క్యూ” వేరియబుల్‌ను దాటడం ద్వారా మేము క్యూను ప్రింట్ చేస్తాము.

పైథాన్ మల్టీప్రాసెసింగ్ క్యూ ఇప్పుడు నిర్మించబడిందని క్రింది చిత్రం చూపిస్తుంది. ప్రింట్ స్టేట్‌మెంట్ మొదట చూపబడుతుంది. ఈ మల్టీప్రాసెసింగ్ క్యూ నిర్దేశించిన మెమరీ చిరునామాలో నిర్మించబడిన తర్వాత, ఇది రెండు లేదా అంతకంటే ఎక్కువ నడుస్తున్న ప్రక్రియల మధ్య విభిన్న డేటాను బదిలీ చేయడానికి ఉపయోగించబడుతుంది.

ఉదాహరణ 2: పైథాన్‌లో మల్టీప్రాసెసింగ్ క్యూ పరిమాణాన్ని నిర్ణయించడానికి “Qsize()” పద్ధతిని ఉపయోగించడం

మేము ఈ సందర్భంలో మల్టీప్రాసెసింగ్ క్యూ పరిమాణాన్ని నిర్ణయిస్తాము. మల్టీప్రాసెసింగ్ క్యూ పరిమాణాన్ని లెక్కించేందుకు, మేము “qsize()” పద్ధతిని ఉపయోగిస్తాము. “qsize()” ఫంక్షన్ పైథాన్ మల్టీప్రాసెసింగ్ క్యూ యొక్క వాస్తవ పరిమాణాన్ని అందిస్తుంది. మరో మాటలో చెప్పాలంటే, ఈ పద్ధతి క్యూలో ఉన్న మొత్తం వస్తువుల సంఖ్యను అందిస్తుంది.

కోడ్‌ని అమలు చేయడానికి ముందు పైథాన్ మల్టీప్రాసెసింగ్ మాడ్యూల్‌ను “m”గా దిగుమతి చేయడం ద్వారా ప్రారంభిద్దాం. అప్పుడు, “m.queue()”కమాండ్‌ని ఉపయోగించి, మేము మల్టీప్రాసెసింగ్ “క్యూ()” ఫంక్షన్‌ని అమలు చేస్తాము మరియు ఫలితాన్ని “క్యూ” వేరియబుల్‌లో ఉంచుతాము. అప్పుడు, “పుట్()” పద్ధతిని ఉపయోగించి, మేము క్రింది లైన్‌లోని అంశాలను క్యూలో జోడిస్తాము. డేటాను క్యూలో జోడించడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది. కాబట్టి, మేము 'పుట్()' పద్ధతితో 'క్యూ' అని పిలుస్తాము మరియు పూర్ణాంక సంఖ్యలను దాని కుండలీకరణంలో దాని మూలకం వలె సరఫరా చేస్తాము. “పుట్()” ఫంక్షన్‌లను ఉపయోగించి మనం జోడించే సంఖ్యలు “1”, “2”, “3”, “4”, “5”, “6,” మరియు “7”.

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

అవుట్‌పుట్ ఇమేజ్ పరిమాణం ప్రదర్శించబడుతుంది. మేము మల్టీప్రాసెసింగ్ క్యూకి ఏడు మూలకాలను జోడించడానికి “put()” ఫంక్షన్‌ను మరియు పరిమాణాన్ని నిర్ణయించడానికి “qsize()” ఫంక్షన్‌ని ఉపయోగిస్తున్నప్పుడు, మల్టీప్రాసెసింగ్ క్యూ పరిమాణం “7” ప్రదర్శించబడుతుంది. ఇన్‌పుట్ స్టేట్‌మెంట్ “మల్టీప్రాసెసింగ్ క్యూ పరిమాణం” పరిమాణానికి ముందు చూపబడుతుంది.

ఉదాహరణ 3: పైథాన్ మల్టీప్రాసెసింగ్ క్యూలో “పుట్()” మరియు “గెట్()” పద్ధతిని ఉపయోగించడం

ఈ ఉదాహరణలో పైథాన్ మల్టీప్రాసెసింగ్ క్యూ నుండి “put()” మరియు “get()” క్యూ పద్ధతులు ఉపయోగించబడ్డాయి. మేము ఈ ఉదాహరణలో రెండు వినియోగదారు నిర్వచించిన ఫంక్షన్‌లను అభివృద్ధి చేస్తాము. ఈ ఉదాహరణలో, '5' యాదృచ్ఛిక పూర్ణాంకాలను ఉత్పత్తి చేసే ప్రక్రియను సృష్టించడానికి మేము ఒక ఫంక్షన్‌ను నిర్వచించాము. మేము వాటిని క్యూలో జోడించడానికి “పుట్()” పద్ధతిని కూడా ఉపయోగిస్తాము. ఐటెమ్‌లను క్యూలో ఉంచడానికి “పుట్()” పద్ధతి ఉపయోగించబడుతుంది. అప్పుడు, క్యూ నుండి సంఖ్యలను తిరిగి పొందడానికి మరియు వాటి విలువలను తిరిగి ఇవ్వడానికి, మేము మరొక ఫంక్షన్ వ్రాసి, ప్రక్రియ సమయంలో దానిని కాల్ చేస్తాము. “పుట్()” పద్ధతిని ఉపయోగించి మనం చొప్పించే క్యూ నుండి డేటాను తిరిగి పొందడానికి ఈ పద్ధతి ఉపయోగించబడుతుంది కాబట్టి మేము క్యూ నుండి సంఖ్యలను తిరిగి పొందడానికి “get()” ఫంక్షన్‌ని ఉపయోగిస్తాము.

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

మేము ఒక ఫంక్షన్‌ని నిర్వచించాము. అప్పుడు, ఈ ఫంక్షన్ వినియోగదారు నిర్వచించబడినందున, మేము దీనికి “ఫంక్షన్1” అనే పేరుని ఇస్తాము మరియు “క్యూ” అనే పదాన్ని దాని వాదనగా పాస్ చేస్తాము. దానిని అనుసరించి, మేము “ప్రింట్()” ఫంక్షన్‌ను అమలు చేస్తాము, దానికి “బిల్డర్: రన్నింగ్”, “ఫ్లష్” మరియు ఆబ్జెక్ట్ “ట్రూ” స్టేట్‌మెంట్‌లను పాస్ చేస్తాము. పైథాన్ యొక్క ప్రింట్ ఫంక్షన్‌లో ఫ్లష్ అనే ప్రత్యేకమైన ఎంపిక ఉంది, ఇది ఈ అవుట్‌పుట్‌ను బఫర్ చేయాలా వద్దా అని ఎంచుకోవడానికి వినియోగదారుని అనుమతిస్తుంది. తదుపరి దశ విధిని రూపొందించడం. దీన్ని చేయడానికి, మేము “for”ని ఉపయోగిస్తాము మరియు వేరియబుల్ “m”ని సృష్టించి, పరిధిని “5”కి సెట్ చేస్తాము. తర్వాత, తదుపరి లైన్‌లో, “ర్యాండమ్()”ని ఉపయోగించండి మరియు ఫలితాన్ని మనం చేసిన వేరియబుల్‌లో నిల్వ చేయండి, అది “విలువ”. ప్రతి పునరావృతం 0 నుండి 5 వరకు యాదృచ్ఛిక పూర్ణాంకాన్ని సృష్టించడంతో, ఫంక్షన్ ఇప్పుడు దాని ఐదు పునరావృత్తులు పూర్తిచేస్తుందని ఇది సూచిస్తుంది.

తరువాత, కింది దశలో, మేము 'స్లీప్()' ఫంక్షన్‌ని పిలుస్తాము మరియు నిర్దిష్ట సంఖ్యలో సెకన్లపాటు భాగాన్ని ఆలస్యం చేయడానికి 'విలువ' వాదనను పాస్ చేస్తాము. ఆపై, క్యూకి విలువను తప్పనిసరిగా జోడించడానికి 'పుట్()' పద్ధతితో 'క్యూ' అని పిలుస్తాము. “queue.put()” పద్ధతిని మరోసారి ప్రారంభించి, “ఏదీ కాదు” విలువను పాస్ చేయడం ద్వారా ఇకపై చేయవలసిన పని లేదని వినియోగదారుకు తెలియజేయబడుతుంది. అప్పుడు, మేము 'ప్రింట్ ()' పద్ధతిని అమలు చేస్తాము, 'ఫ్లష్'తో పాటు 'బిల్డర్: సిద్ధంగా' స్టేట్‌మెంట్‌ను పాస్ చేసి, దానిని 'ట్రూ'కి సెట్ చేస్తాము.

మేము ఇప్పుడు రెండవ ఫంక్షన్, “function2”ని నిర్వచించాము మరియు దానికి “క్యూ” అనే కీవర్డ్‌ని దాని వాదనగా కేటాయించాము. ఆపై, 'యూజర్: రన్నింగ్' మరియు 'ఫ్లష్' అనే నివేదికను పాస్ చేస్తున్నప్పుడు మేము 'ప్రింట్()' ఫంక్షన్‌ని పిలుస్తాము, ఇది 'ట్రూ'కి సెట్ చేయబడింది. మేము 'ఫంక్షన్2' యొక్క ఆపరేషన్‌ను క్యూ నుండి డేటాను తీసివేసి, కొత్తగా సృష్టించిన 'ఐటెమ్' వేరియబుల్‌లో ఉంచడానికి ట్రూ కండిషన్‌ను ఉపయోగించి ప్రారంభిస్తాము. అప్పుడు, షరతు నిజమైతే లూప్‌కు అంతరాయం కలిగించడానికి మేము “if” షరతును ఉపయోగిస్తాము, “అంశం ఏదీ కాదు”. ఐటెమ్ ఏదీ అందుబాటులో లేకుంటే, అది ఆపివేసి వినియోగదారుని ఒకదాని కోసం అడుగుతుంది. టాస్క్ లూప్‌ను ఆపివేస్తుంది మరియు విలువ నుండి పొందిన అంశం శూన్యంగా ఉంటే ఈ సందర్భంలో ముగుస్తుంది. తరువాత, కింది దశలో, మేము “ప్రింట్()” ఫంక్షన్‌ని పిలుస్తాము మరియు దానికి “యూజర్: రెడీ” రిపోర్ట్ మరియు “ఫ్లష్=ట్రూ” పారామితులను అందిస్తాము.

అప్పుడు, మేము 'If-name = main_'ని ఉపయోగించి ప్రధాన ప్రక్రియను నమోదు చేస్తాము. మేము 'క్యూ()' పద్ధతికి కాల్ చేసి, దానిని 'క్యూ' వేరియబుల్‌లో నిల్వ చేయడం ద్వారా క్యూను సృష్టిస్తాము. తరువాత, మేము వినియోగదారు ఫంక్షన్ 'function2' అని పిలవడం ద్వారా ఒక ప్రక్రియను సృష్టిస్తాము. దీని కోసం, మేము 'ప్రాసెస్' తరగతి అని పిలుస్తాము. దాని లోపల, మేము ప్రాసెస్‌లో ఫంక్షన్‌ని కాల్ చేయడానికి “టార్గెట్=ఫంక్షన్2”ని పాస్ చేస్తాము, ఆర్గ్యుమెంట్ “క్యూ”ని పాస్ చేసి, దానిని “యూజర్_ప్రాసెస్” వేరియబుల్‌లో నిల్వ చేస్తాము. “User_ process” వేరియబుల్‌తో “start()” పద్ధతిని కాల్ చేయడం ద్వారా ప్రక్రియ ప్రారంభమవుతుంది. మేము ప్రక్రియలో “ఫంక్షన్1” అని పిలవడానికి అదే విధానాన్ని పునరావృతం చేస్తాము మరియు దానిని “బిల్డర్ ప్రాసెస్” వేరియబుల్‌లో ఉంచుతాము. ఆపై, అమలు కోసం వేచి ఉండటానికి మేము ప్రక్రియలను 'చేరండి()' పద్ధతితో పిలుస్తాము.

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

ముగింపు

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