కొరౌటిన్లు జెనరేటర్‌ల భావనపై ఆధారపడి ఉంటాయి, ఇక్కడ ఒక ఫంక్షన్ విలువలను అందించగలదు మరియు తర్వాత అమలును కొనసాగించడానికి పునఃప్రారంభించబడుతుంది. అసమకాలిక కార్యకలాపాలను నిర్వహించడానికి Coroutineలు శక్తివంతమైన సాధనాన్ని అందిస్తాయి మరియు మీ కోడ్ యొక్క మొత్తం నాణ్యతను బాగా మెరుగుపరుస్తాయి.
Coroutines యొక్క ఉపయోగాలు
ఆధునిక ప్రోగ్రామింగ్‌లో, ముఖ్యంగా C++ వంటి భాషల్లో అనేక కారణాల వల్ల కొరౌటిన్లు అవసరమవుతాయి. కొరౌటిన్లు ప్రయోజనకరంగా ఉండటానికి ఇక్కడ కొన్ని ముఖ్య కారణాలు ఉన్నాయి:
అసమకాలిక ప్రోగ్రామింగ్‌కు కొరౌటిన్లు సొగసైన పరిష్కారాన్ని అందిస్తాయి. అవి సీక్వెన్షియల్‌గా కనిపించే కోడ్‌ని సృష్టించడం సాధ్యం చేస్తాయి మరియు దాని గురించి తర్కించడం మరియు అర్థం చేసుకోవడం సులభం. ఇతర టాస్క్‌ల సమాంతర ఆపరేషన్‌ను ఎనేబుల్ చేస్తూ, థ్రెడ్‌లను నిరోధించకుండా, కొరౌటిన్లు నిర్దిష్ట పాయింట్‌ల వద్ద వాటి అమలును నిలిపివేయవచ్చు. దీని కారణంగా, సిస్టమ్ వనరులు మరింత ప్రభావవంతంగా ఉపయోగించబడవచ్చు మరియు I/O కార్యకలాపాలను కలిగి ఉన్న లేదా బాహ్య ఈవెంట్‌ల కోసం వేచి ఉండే అప్లికేషన్‌లలో ప్రతిస్పందన పెరుగుతుంది.
వారు కోడ్‌ను అర్థం చేసుకోవడం మరియు నిర్వహించడం సులభం చేయవచ్చు. సంక్లిష్టమైన కాల్‌బ్యాక్ చైన్‌లు లేదా స్టేట్ మెషీన్‌లను తొలగించడం ద్వారా, కొరౌటిన్లు కోడ్‌ను మరింత సరళ మరియు వరుస శైలిలో వ్రాయడానికి వీలు కల్పిస్తాయి. ఇది కోడ్ ఆర్గనైజేషన్‌ని మెరుగుపరుస్తుంది, గూడు కట్టడాన్ని తగ్గిస్తుంది మరియు తర్కాన్ని సులభంగా గ్రహించేలా చేస్తుంది.
కొరౌటిన్లు సమకాలీకరణ మరియు సమాంతరతను నిర్వహించడానికి నిర్మాణాత్మక మార్గాన్ని అందిస్తాయి. మరింత స్పష్టమైన వాక్యనిర్మాణాన్ని ఉపయోగించి సంక్లిష్ట సమన్వయ నమూనాలు మరియు అసమకాలిక వర్క్‌ఫ్లోలను వ్యక్తీకరించడానికి అవి మిమ్మల్ని అనుమతిస్తాయి. థ్రెడ్‌లు బ్లాక్ చేయబడే సంప్రదాయ థ్రెడింగ్ మోడల్‌ల వలె కాకుండా, కొరౌటిన్లు సిస్టమ్ వనరులను ఖాళీ చేయగలవు మరియు సమర్థవంతమైన మల్టీ టాస్కింగ్‌ను ప్రారంభించగలవు.
C++లో కొరౌటిన్‌ల అమలును ప్రదర్శించడానికి కొన్ని ఉదాహరణలను రూపొందిద్దాం.
ఉదాహరణ 1: బేసిక్ కరోటిన్స్
ప్రాథమిక కరోటిన్ ఉదాహరణ క్రింది వాటిలో అందించబడింది:
#
#
నిర్మాణం ఈకోరౌట్ {
నిర్మాణం వాగ్దానం_రకం {
ఈకోరౌట్ గెట్_రిటర్న్_ఆబ్జెక్ట్ ( ) { తిరిగి { } ; }
std :: సస్పెండ్_ఎప్పటికీ ప్రారంభ_సస్పెండ్ ( ) { తిరిగి { } ; }
std :: సస్పెండ్_ఎప్పటికీ చివరి_సస్పెండ్ ( ) తప్ప { తిరిగి { } ; }
శూన్యం హ్యాండిల్ చేయని_మినహాయింపు ( ) { }
శూన్యం తిరిగి_శూన్యం ( ) { }
} ;
బూల్ వేచి ఉంది_సిద్ధంగా ( ) { తిరిగి తప్పుడు ; }
శూన్యం నిరీక్షించు_సస్పెండ్ ( std :: కొరూటిన్_హ్యాండిల్ <> h ) { }
శూన్యం నిరీక్షించు_రెస్యూమ్ ( ) { std :: కోట్ << 'కోరూటిన్ పునఃప్రారంభించబడింది.' << std :: endl ; }
} ;
ఈకోరౌట్ ఫూ ( ) {
std :: కోట్ << 'కోరూటిన్ ప్రారంభమైంది.' << std :: endl ;
సహ_వెయిట్ std :: సస్పెండ్_ఎల్లప్పుడూ { } ;
సహ_తిరిగి ;
}
int ప్రధాన ( ) {
దానంతట అదే cr = foo ( ) ;
std :: కోట్ << 'కోరూటిన్ సృష్టించబడింది.' << std :: endl ;
cr. నిరీక్షించు_రెస్యూమ్ ( ) ;
std :: కోట్ << 'కొరోటిన్ పూర్తయింది.' << std :: endl ;
తిరిగి 0 ;
}
మునుపు అందించిన కోడ్‌ని పరిశీలిద్దాం మరియు దానిని వివరంగా వివరించండి:
అవసరమైన హెడర్ ఫైల్‌లను చేర్చిన తర్వాత, మేము కొరౌటిన్‌ను సూచించే “దిస్‌కోరౌట్” నిర్మాణాన్ని నిర్వచించాము. 'దిస్‌కోరౌట్' లోపల, 'ప్రామిస్_టైప్' అని మరొక నిర్మాణం నిర్వచించబడింది, అది కొరౌటిన్ వాగ్దానాన్ని నిర్వహిస్తుంది. ఈ నిర్మాణం కొరోటిన్ యంత్రాలకు అవసరమైన వివిధ విధులను అందిస్తుంది.
బ్రాకెట్ల లోపల, మేము get_return_object() ఫంక్షన్‌ని ఉపయోగిస్తాము. ఇది కొరోటిన్ వస్తువును తిరిగి ఇస్తుంది. ఈ సందర్భంలో, ఇది ఖాళీ “దిస్‌కోరౌట్” వస్తువును అందిస్తుంది. అప్పుడు, ఇనీషియల్_సస్పెండ్() ఫంక్షన్ ప్రారంభించబడుతుంది, ఇది కరోటిన్ మొదట ప్రారంభించబడినప్పుడు ప్రవర్తనను నిర్ణయిస్తుంది. std::suspend_never అంటే కరోటిన్‌ని ప్రారంభంలో సస్పెండ్ చేయకూడదు.
ఆ తర్వాత, మేము కరోటిన్ పూర్తి చేయబోతున్నప్పుడు ప్రవర్తనను నిర్ణయించే final_suspend() ఫంక్షన్‌ని కలిగి ఉన్నాము. std::suspend_never అంటే కరోటిన్‌ని ఖరారు చేసే ముందు సస్పెండ్ చేయకూడదు.
ఒక కరోటిన్ మినహాయింపును విసిరితే, unhandled_exception() పద్ధతి అమలు చేయబడుతుంది. ఈ ఉదాహరణలో, ఇది ఖాళీ ఫంక్షన్, కానీ మీరు అవసరమైన విధంగా మినహాయింపులను నిర్వహించవచ్చు. కరోటిన్ విలువను అందించకుండా ముగించినప్పుడు, return_void() పద్ధతి అమలు చేయబడుతుంది. ఈ సందర్భంలో, ఇది కూడా ఖాళీ ఫంక్షన్.
మేము 'దిస్‌కోరౌట్'లో ముగ్గురు సభ్యుల ఫంక్షన్‌లను కూడా నిర్వచించాము. ఎగ్జిక్యూషన్‌ను తిరిగి ప్రారంభించడానికి కరోటిన్ సిద్ధంగా ఉందో లేదో తనిఖీ చేయడానికి await_ready() ఫంక్షన్‌ని పిలుస్తారు. ఈ ఉదాహరణలో, ఇది ఎల్లప్పుడూ తప్పుగా తిరిగి వస్తుంది, ఇది కరోటిన్ వెంటనే పునఃప్రారంభించడానికి సిద్ధంగా లేదని సూచిస్తుంది. కరోటిన్ సస్పెండ్ చేయబోతున్నప్పుడు, పద్ధతి await_suspend() అంటారు. ఇక్కడ, ఇది ఖాళీ ఫంక్షన్ అంటే సస్పెన్షన్ అవసరం లేదు. సస్పెన్షన్ తర్వాత కరోటిన్ పునఃప్రారంభించబడినప్పుడు ప్రోగ్రామ్ await_resume()ని పిలుస్తుంది. ఇది కేవలం కరోటిన్ పునఃప్రారంభించబడిందని తెలిపే సందేశాన్ని అందిస్తుంది.
కోడ్ యొక్క తదుపరి పంక్తులు foo() కరోటిన్ ఫంక్షన్‌ను నిర్వచించాయి. foo() లోపల, మేము కరోటిన్ ప్రారంభమైందని తెలిపే సందేశాన్ని ముద్రించడం ద్వారా ప్రారంభిస్తాము. ఆ తర్వాత, co_await std::suspend_always{} అనేది కరోటిన్‌ను సస్పెండ్ చేయడానికి ఉపయోగించబడుతుంది మరియు తర్వాతి సమయంలో దాన్ని పునఃప్రారంభించవచ్చని సూచిస్తుంది. కో_రిటర్న్ స్టేట్‌మెంట్ ఎలాంటి విలువను తిరిగి ఇవ్వకుండా కరోటిన్‌ను పూర్తి చేయడానికి ఉపయోగించబడుతుంది.
మెయిన్() ఫంక్షన్‌లో, మేము foo()ని కాల్ చేయడం ద్వారా “దిస్‌కోరౌట్” రకం “cr” వస్తువును నిర్మిస్తాము. ఇది కరోటిన్‌ను సృష్టిస్తుంది మరియు ప్రారంభిస్తుంది. అప్పుడు, కరోటిన్ సృష్టించబడిందని తెలిపే సందేశం ముద్రించబడుతుంది. తరువాత, మేము దాని అమలును పునఃప్రారంభించడానికి “cr” కరోటిన్ ఆబ్జెక్ట్‌పై await_resume()ని పిలుస్తాము. await_resume() లోపల, “The Coroutine is resume” సందేశం ముద్రించబడింది. చివరగా, ప్రోగ్రామ్ ముగిసేలోపు కరోటిన్ పూర్తయిందని తెలిపే సందేశాన్ని మేము ప్రదర్శిస్తాము.
మీరు ఈ ప్రోగ్రామ్‌ని అమలు చేసినప్పుడు, అవుట్‌పుట్ క్రింది విధంగా ఉంటుంది:
ఉదాహరణ 2: పారామితులు మరియు దిగుబడితో కూడిన కొరూటిన్
ఇప్పుడు, ఈ దృష్టాంతం కోసం, సంఖ్యల క్రమాన్ని ఉత్పత్తి చేయడానికి జనరేటర్-వంటి ప్రవర్తనను సృష్టించడానికి పారామితులతో మరియు C++లో దిగుబడినిచ్చే కొరౌటిన్‌ల వినియోగాన్ని ప్రదర్శించే కోడ్‌ను మేము అందిస్తాము.
##
#
నిర్మాణం కొత్తకొరొటిన్ {
నిర్మాణం p_type {
std :: వెక్టర్ < int > విలువలు ;
NEWCoroutine get_return_object ( ) { తిరిగి { } ; }
std :: సస్పెండ్_ఎల్లప్పుడూ ప్రారంభ_సస్పెండ్ ( ) { తిరిగి { } ; }
std :: సస్పెండ్_ఎల్లప్పుడూ చివరి_సస్పెండ్ ( ) తప్ప { తిరిగి { } ; }
శూన్యం హ్యాండిల్ చేయని_మినహాయింపు ( ) { }
శూన్యం తిరిగి_శూన్యం ( ) { }
std :: సస్పెండ్_ఎల్లప్పుడూ దిగుబడి_విలువ ( int విలువ ) {
విలువలు. వెనుకకు నెట్టడం ( విలువ ) ;
తిరిగి { } ;
}
} ;
std :: వెక్టర్ < int > విలువలు ;
నిర్మాణం పునరావృతం చేసేవాడు {
std :: కొరూటిన్_హ్యాండిల్ <> కోరస్_హ్యాండిల్ ;
bool ఆపరేటర్ != ( స్థిరంగా పునరావృతం చేసేవాడు & ఇతర ) స్థిరంగా { తిరిగి కోరస్_హ్యాండిల్ != ఇతర. కోరస్_హ్యాండిల్ ; }
పునరావృతం చేసేవాడు & ఆపరేటర్ ++ ( ) { కోరస్_హ్యాండిల్. పునఃప్రారంభం ( ) ; తిరిగి * ఇది ; }
int ఆపరేటర్ * ( ) స్థిరంగా { తిరిగి కోరస్_హ్యాండిల్. వాగ్దానం ( ) . విలువలు [ 0 ] ; }
} ;
ఇటరేటర్ ప్రారంభమవుతుంది ( ) { తిరిగి పునరావృతం చేసేవాడు { std :: కొరూటిన్_హ్యాండిల్ < p_type >:: నుండి_ప్రామిస్ ( వాగ్దానం ( ) ) } ; }
పునరావృత్తి ముగింపు ( ) { తిరిగి పునరావృతం చేసేవాడు { nullptr } ; }
std :: కొరూటిన్_హ్యాండిల్ < p_type > వాగ్దానం ( ) { తిరిగి
std :: కొరూటిన్_హ్యాండిల్ < p_type >:: నుండి_ప్రామిస్ ( * ఇది ) ; }
} ;
కొత్తకొరోటిన్ సంఖ్యలను ఉత్పత్తి చేస్తుంది ( ) {
సహ_దిగుబడి 5 ;
సహ_దిగుబడి 6 ;
సహ_దిగుబడి 7 ;
}
int ప్రధాన ( ) {
కొత్తకొరోటిన్ ఎన్‌సి = సంఖ్యలను రూపొందించండి ( ) ;
కోసం ( int విలువ : nc ) {
std :: కోట్ << విలువ << '' ;
}
std :: కోట్ << std :: endl ;
తిరిగి 0 ;
}
మునుపటి కోడ్‌లో, NEWCoroutine struct అనేది కొరోటిన్-ఆధారిత జనరేటర్‌ను సూచిస్తుంది. ఇది కొరౌటిన్‌కు వాగ్దానం రకంగా పనిచేసే సమూహ “p_type” నిర్మాణాన్ని కలిగి ఉంది. p_type struct అనేది get_return_object(), initial_suspend(), final_suspend(), unhandled_exception(), మరియు return_void() వంటి కరోటిన్ మెషినరీకి అవసరమైన ఫంక్షన్‌లను నిర్వచిస్తుంది. p_type struct కూడా ఈల్డ్_వాల్యూ (పూర్ణాంక విలువ) ఫంక్షన్‌ని కలిగి ఉంటుంది, ఇది కొరూటిన్ నుండి విలువలను అందించడానికి ఉపయోగించబడుతుంది. ఇది అందించిన విలువను విలువల వెక్టర్‌కు జోడిస్తుంది.
NEWCoroutine struct std::vector
మేము p_type వాగ్దానం నుండి coro_handleని పొందడం ద్వారా కరోటిన్ ప్రారంభంలో ఇటరేటర్‌ని సృష్టించడానికి బిగిన్() ఫంక్షన్‌ని ఉపయోగిస్తాము. అయితే ఎండ్() ఫంక్షన్ ఒక ఇటరేటర్‌ను సృష్టిస్తుంది, అది కరోటిన్ ముగింపును సూచిస్తుంది మరియు nullptr coro_handleతో నిర్మించబడింది. ఆ తర్వాత, p_type ప్రామిస్ నుండి coroutine_handleని సృష్టించడం ద్వారా వాగ్దానం రకాన్ని తిరిగి ఇవ్వడానికి ప్రామిస్() ఫంక్షన్ ఉపయోగించబడుతుంది. జనరేట్ నంబర్స్() ఫంక్షన్ అనేది కో_యీల్డ్ కీవర్డ్‌ని ఉపయోగించి మూడు విలువలను - 5, 6 మరియు 7లను అందించే కొరూటిన్.
ప్రధాన() ఫంక్షన్‌లో, 'nc' అనే పేరు గల NEWCoroutine యొక్క ఉదాహరణ జనరేట్ నంబర్స్() కొరౌటిన్‌ను ప్రారంభించడం ద్వారా సృష్టించబడుతుంది. ఇది కరోటిన్‌ను ప్రారంభిస్తుంది మరియు దాని స్థితిని సంగ్రహిస్తుంది. 'nc' విలువలపై పునరావృతం చేయడానికి శ్రేణి-ఆధారిత 'ఫర్' లూప్ ఉపయోగించబడుతుంది మరియు ప్రతి విలువ std::cout ఉపయోగించి ఖాళీతో వేరు చేయబడి ముద్రించబడుతుంది.
ఉత్పత్తి చేయబడిన అవుట్‌పుట్ క్రింది విధంగా ఉంది:
ముగింపు
ఈ కథనం C++లో కొరౌటిన్‌ల వినియోగాన్ని ప్రదర్శిస్తుంది. మేము రెండు ఉదాహరణలను చర్చించాము. మొదటి ఉదాహరణ కోసం, కరోటిన్ ఫంక్షన్‌లను ఉపయోగించి C++ ప్రోగ్రామ్‌లో ప్రాథమిక కరోటిన్ సృష్టించబడుతుంది. రెండవ ప్రదర్శన పారామితులతో కొరోటిన్‌లను ఉపయోగించడం ద్వారా మరియు సంఖ్యల క్రమాన్ని సృష్టించడానికి జనరేటర్ లాంటి ప్రవర్తనను రూపొందించడం ద్వారా నిర్వహించబడింది.