கொரூட்டின்கள் ஜெனரேட்டர்களின் கருத்தை அடிப்படையாகக் கொண்டவை, அங்கு ஒரு செயல்பாடு மதிப்புகளை அளிக்கும் மற்றும் பின்னர் செயல்படுத்தலைத் தொடர மீண்டும் தொடங்கும். ஒத்திசைவற்ற செயல்பாடுகளை நிர்வகிப்பதற்கான சக்திவாய்ந்த கருவியை Coroutines வழங்குவதோடு உங்கள் குறியீட்டின் ஒட்டுமொத்த தரத்தையும் பெரிதும் மேம்படுத்த முடியும்.
கரோட்டின்களின் பயன்பாடுகள்
நவீன நிரலாக்கத்தில், குறிப்பாக C++ போன்ற மொழிகளில் பல காரணங்களுக்காக Coroutineகள் தேவைப்படுகின்றன. கரோட்டின்கள் நன்மை பயக்கும் சில முக்கிய காரணங்கள் இங்கே:
ஒத்திசைவற்ற நிரலாக்கத்திற்கு Coroutines ஒரு நேர்த்தியான தீர்வை வழங்குகிறது. அவை வரிசையாகத் தோன்றும் குறியீட்டை உருவாக்குவதை சாத்தியமாக்குகிறது மற்றும் தடுக்கிறது, இது பகுத்தறிவதற்கும் புரிந்துகொள்வதற்கும் எளிதானது. மற்ற பணிகளின் இணையான செயல்பாட்டை செயல்படுத்துவதன் மூலம், த்ரெட்களைத் தடுக்காமல், கரோட்டின்கள் குறிப்பிட்ட புள்ளிகளில் தங்கள் செயல்பாட்டை நிறுத்தி வைக்கலாம். இதன் காரணமாக, கணினி வளங்கள் மிகவும் திறம்பட பயன்படுத்தப்படலாம், மேலும் I/O செயல்பாடுகளை உள்ளடக்கிய அல்லது வெளிப்புற நிகழ்வுகளுக்காக காத்திருக்கும் பயன்பாடுகளில் பதிலளிக்கும் திறன் அதிகரிக்கிறது.
அவர்கள் குறியீட்டைப் புரிந்துகொள்வதற்கும் பராமரிப்பதற்கும் எளிதாக்கலாம். சிக்கலான கால்பேக் சங்கிலிகள் அல்லது ஸ்டேட் மெஷின்களை நீக்குவதன் மூலம், கோரோட்டின்கள் குறியீட்டை இன்னும் நேரியல் மற்றும் வரிசையான பாணியில் எழுத உதவுகிறது. இது குறியீட்டு அமைப்பை மேம்படுத்துகிறது, கூடு கட்டுவதைக் குறைக்கிறது மற்றும் தர்க்கத்தைப் புரிந்துகொள்வதை எளிதாக்குகிறது.
கொரூட்டின்கள் ஒத்திசைவு மற்றும் இணையான தன்மையைக் கையாள ஒரு கட்டமைக்கப்பட்ட வழியை வழங்குகின்றன. சிக்கலான ஒருங்கிணைப்பு முறைகள் மற்றும் ஒத்திசைவற்ற பணிப்பாய்வுகளை மிகவும் உள்ளுணர்வு தொடரியல் மூலம் வெளிப்படுத்த அவை உங்களை அனுமதிக்கின்றன. த்ரெட்கள் தடுக்கப்படும் பாரம்பரிய த்ரெடிங் மாதிரிகள் போலல்லாமல், கரோட்டின்கள் கணினி வளங்களை விடுவித்து, திறமையான பல்பணியை செயல்படுத்த முடியும்.
C++ இல் coroutines செயல்படுத்தப்படுவதை நிரூபிக்க சில எடுத்துக்காட்டுகளை உருவாக்குவோம்.
எடுத்துக்காட்டு 1: அடிப்படை கரோட்டின்கள்
அடிப்படை கரோட்டின்களின் எடுத்துக்காட்டு பின்வருவனவற்றில் வழங்கப்படுகிறது:
#
#
கட்டமைக்க இந்த கோரவுட் {
கட்டமைக்க வாக்குறுதி_வகை {
ThisCorout get_return_object ( ) { திரும்ப { } ; }
வகுப்பு :: இடைநிறுத்த_வேண்டாம் ஆரம்ப_தடுப்பு ( ) { திரும்ப { } ; }
வகுப்பு :: இடைநிறுத்த_வேண்டாம் இறுதி_தடுப்பு ( ) தவிர { திரும்ப { } ; }
வெற்றிடமானது கையாளப்படாத_விதிவிலக்கு ( ) { }
வெற்றிடமானது திரும்ப_செல்லாதது ( ) { }
} ;
bool வெயிட்_ரெடி ( ) { திரும்ப பொய் ; }
வெற்றிடமானது காத்திரு_தடுப்பு ( வகுப்பு :: கொரூட்டின்_கைப்பிடி <> ம ) { }
வெற்றிடமானது காத்திருக்கவும் ( ) { வகுப்பு :: கூட் << 'கரோட்டின் மீண்டும் தொடங்கப்பட்டது.' << வகுப்பு :: endl ; }
} ;
இந்த கோரவுட் ஃபூ ( ) {
வகுப்பு :: கூட் << 'கரோட்டின் தொடங்கியது.' << வகுப்பு :: endl ;
co_wait std :: இடைநீக்கம்_எப்போதும் { } ;
இணை_திரும்பல் ;
}
முழு எண்ணாக முக்கிய ( ) {
ஆட்டோ cr = foo ( ) ;
வகுப்பு :: கூட் << 'கரோட்டின் உருவாக்கப்பட்டது.' << வகுப்பு :: endl ;
cr. காத்திருக்கவும் ( ) ;
வகுப்பு :: கூட் << 'கொரூட்டின் முடிந்தது.' << வகுப்பு :: endl ;
திரும்ப 0 ;
}
முன்னர் வழங்கப்பட்ட குறியீட்டைப் பார்த்து அதை விரிவாக விளக்குவோம்:
தேவையான தலைப்புக் கோப்புகளைச் சேர்த்த பிறகு, கொரூட்டினைக் குறிக்கும் 'திஸ்கொரௌட்' கட்டமைப்பை வரையறுக்கிறோம். 'திஸ்கொரௌட்' இன் உள்ளே, 'வாக்குறுதி_வகை' என்ற மற்றொரு அமைப்பு வரையறுக்கப்பட்டுள்ளது, அது coroutine வாக்குறுதியைக் கையாளுகிறது. கரோட்டின் இயந்திரங்களுக்குத் தேவையான பல்வேறு செயல்பாடுகளை இந்த அமைப்பு வழங்குகிறது.
அடைப்புக்குறிக்குள், get_return_object() செயல்பாட்டைப் பயன்படுத்துகிறோம். இது கரோட்டின் பொருளையே திருப்பித் தருகிறது. இந்த நிகழ்வில், இது ஒரு வெற்று 'திஸ்கொரௌட்' பொருளை வழங்குகிறது. பின்னர், ஆரம்ப_சஸ்பெண்ட்() செயல்பாடு செயல்படுத்தப்படுகிறது, இது கரோட்டின் முதலில் தொடங்கும் போது நடத்தை தீர்மானிக்கிறது. std::suspend_never என்பது கரோட்டினை ஆரம்பத்தில் இடைநீக்கம் செய்யக்கூடாது என்று அர்த்தம்.
அதன் பிறகு, எங்களிடம் ஃபைனல்_சஸ்பெண்ட்() செயல்பாடு உள்ளது, இது கரோட்டின் முடிவடையும் போது நடத்தையை தீர்மானிக்கிறது. std::suspend_never என்பது கரோட்டினை இறுதி செய்வதற்கு முன் இடைநிறுத்தப்படக்கூடாது என்பதாகும்.
ஒரு கரோட்டின் விதிவிலக்கு அளித்தால், unhandled_exception() முறை செயல்படுத்தப்படும். இந்த எடுத்துக்காட்டில், இது ஒரு வெற்று செயல்பாடு, ஆனால் தேவைக்கேற்ப விதிவிலக்குகளை நீங்கள் கையாளலாம். ஒரு மதிப்பை வழங்காமல் கரோட்டின் முடிவடையும் போது, return_void() முறை செயல்படுத்தப்படுகிறது. இந்த வழக்கில், இது ஒரு வெற்று செயல்பாடு.
'திஸ்கார்அவுட்' க்குள் மூன்று உறுப்பினர் செயல்பாடுகளையும் நாங்கள் வரையறுக்கிறோம். await_ready() செயல்பாடானது, கொரூட்டின் செயல்படுத்தலைத் தொடங்கத் தயாராக உள்ளதா என்பதைச் சரிபார்க்க அழைக்கப்படுகிறது. இந்த எடுத்துக்காட்டில், அது எப்பொழுதும் தவறானதாகத் திரும்பும், இது கரோட்டின் உடனடியாக மீண்டும் தொடங்கத் தயாராக இல்லை என்பதைக் குறிக்கிறது. coroutine இடைநிறுத்தப்படும் போது, await_suspend() முறை அழைக்கப்படுகிறது. இங்கே, இது ஒரு வெற்று செயல்பாடு, அதாவது இடைநீக்கம் தேவையில்லை. இடைநீக்கத்திற்குப் பிறகு கொரூட்டின் மீண்டும் தொடங்கும் போது நிரல் await_resume() ஐ அழைக்கிறது. இது கரோட்டின் மீண்டும் தொடங்கப்பட்டது என்று ஒரு செய்தியை வெளியிடுகிறது.
குறியீட்டின் அடுத்த வரிகள் foo() coroutine செயல்பாட்டை வரையறுக்கின்றன. உள்ளே foo(), coroutine தொடங்கிவிட்டது என்று ஒரு செய்தியை அச்சிடுவதன் மூலம் தொடங்குகிறோம். பிறகு, co_await std::suspend_always{} என்பது கரோட்டினை இடைநிறுத்தப் பயன்படுகிறது, மேலும் இது பின்னர் மீண்டும் தொடங்கப்படலாம் என்பதைக் குறிக்கிறது. co_return ஸ்டேட்மெண்ட் எந்த மதிப்பையும் தராமல் coroutine ஐ முடிக்கப் பயன்படுகிறது.
மெயின்() செயல்பாட்டில், foo() ஐ அழைப்பதன் மூலம் 'TheCorout' வகையின் 'cr' ஒரு பொருளை உருவாக்குகிறோம். இது கரோட்டினை உருவாக்கி தொடங்குகிறது. பின்னர், கரோட்டின் உருவாக்கப்பட்டுள்ளது என்று ஒரு செய்தி அச்சிடப்படுகிறது. அடுத்து, 'cr' கரோட்டின் பொருளின் செயல்பாட்டை மீண்டும் தொடங்க, await_resume() ஐ அழைக்கிறோம். await_resume()ன் உள்ளே, “The Coroutine is resume” என்ற செய்தி அச்சிடப்பட்டுள்ளது. இறுதியாக, நிரல் முடிவடைவதற்குள் கரோட்டின் முடிந்துவிட்டது என்ற செய்தியைக் காண்பிப்போம்.
இந்த நிரலை இயக்கும்போது, வெளியீடு பின்வருமாறு:
எடுத்துக்காட்டு 2: அளவுருக்கள் மற்றும் மகசூல் கொண்ட கொரூட்டின்
இப்போது, இந்த விளக்கத்திற்காக, எண்களின் வரிசையை உருவாக்க ஜெனரேட்டர் போன்ற நடத்தையை உருவாக்க, அளவுருக்கள் மற்றும் C++ இல் விளைச்சலைக் கொண்ட கரோட்டின்களின் பயன்பாட்டை நிரூபிக்கும் குறியீட்டை நாங்கள் வழங்குகிறோம்.
##
#
கட்டமைக்க புதிய கரோட்டின் {
கட்டமைக்க p_type {
வகுப்பு :: திசையன் < முழு எண்ணாக > மதிப்புகள் ;
NEWCoroutine get_return_object ( ) { திரும்ப { } ; }
வகுப்பு :: இடைநீக்கம்_எப்போதும் ஆரம்ப_தடுப்பு ( ) { திரும்ப { } ; }
வகுப்பு :: இடைநீக்கம்_எப்போதும் இறுதி_தடுப்பு ( ) தவிர { திரும்ப { } ; }
வெற்றிடமானது கையாளப்படாத_விதிவிலக்கு ( ) { }
வெற்றிடமானது திரும்ப_செல்லாதது ( ) { }
வகுப்பு :: இடைநீக்கம்_எப்போதும் விளைச்சல்_மதிப்பு ( முழு எண்ணாக மதிப்பு ) {
மதிப்புகள். பின் தள்ளு ( மதிப்பு ) ;
திரும்ப { } ;
}
} ;
வகுப்பு :: திசையன் < முழு எண்ணாக > மதிப்புகள் ;
கட்டமைக்க மீண்டும் செய்பவர் {
வகுப்பு :: கொரூட்டின்_கைப்பிடி <> கோரஸ்_கைப்பிடி ;
பூல் ஆபரேட்டர் != ( நிலையான மீண்டும் செய்பவர் & மற்றவை ) நிலையான { திரும்ப கோரஸ்_கைப்பிடி != மற்றவை. கோரஸ்_கைப்பிடி ; }
மீண்டும் செய்பவர் & இயக்குபவர் ++ ( ) { கோரஸ்_கைப்பிடி. தற்குறிப்பு ( ) ; திரும்ப * இது ; }
முழு எண்ணாக இயக்குபவர் * ( ) நிலையான { திரும்ப கோரஸ்_கைப்பிடி. வாக்குறுதி ( ) . மதிப்புகள் [ 0 ] ; }
} ;
மறு செய்கை தொடங்கும் ( ) { திரும்ப மீண்டும் செய்பவர் { வகுப்பு :: கொரூட்டின்_கைப்பிடி < p_type >:: இருந்து_வாக்கு ( வாக்குறுதி ( ) ) } ; }
மறு செய்கை முனை ( ) { திரும்ப மீண்டும் செய்பவர் { nullptr } ; }
வகுப்பு :: கொரூட்டின்_கைப்பிடி < p_type > வாக்குறுதி ( ) { திரும்ப
வகுப்பு :: கொரூட்டின்_கைப்பிடி < p_type >:: இருந்து_வாக்கு ( * இது ) ; }
} ;
புதிய கொரூட்டின் எண்களை உருவாக்குகிறது ( ) {
இணை_விளைச்சல் 5 ;
இணை_விளைச்சல் 6 ;
இணை_விளைச்சல் 7 ;
}
முழு எண்ணாக முக்கிய ( ) {
NEWCoroutine nc = எண்களை உருவாக்குகிறது ( ) ;
க்கான ( முழு எண்ணாக மதிப்பு : என்சி ) {
வகுப்பு :: கூட் << மதிப்பு << '' ;
}
வகுப்பு :: கூட் << வகுப்பு :: endl ;
திரும்ப 0 ;
}
முந்தைய குறியீட்டில், NEWCoroutine struct என்பது கரோட்டின் அடிப்படையிலான ஜெனரேட்டரைக் குறிக்கிறது. இது ஒரு உள்ளமைக்கப்பட்ட “p_type” கட்டமைப்பைக் கொண்டுள்ளது, இது கரோட்டினுக்கான வாக்குறுதி வகையாக செயல்படுகிறது. p_type struct ஆனது, get_return_object(), initial_suspend(), final_suspend(), unhandled_exception(), மற்றும் return_void() போன்ற கரோட்டின் இயந்திரங்களுக்குத் தேவைப்படும் செயல்பாடுகளை வரையறுக்கிறது. p_type struct ஆனது க்ரோட்டினிலிருந்து மதிப்புகளை வழங்கப் பயன்படும் விளைச்சல்_மதிப்பு (int மதிப்பு) செயல்பாட்டையும் உள்ளடக்கியது. இது வழங்கப்பட்ட மதிப்பை மதிப்புகள் திசையனுடன் சேர்க்கிறது.
NEWCoroutine struct ஆனது std::vector
p_type வாக்குறுதியிலிருந்து coro_handle ஐப் பெறுவதன் மூலம், coroutine இன் தொடக்கத்தில் ஒரு மறு செய்கையை உருவாக்குவதற்கு நாம் start() செயல்பாட்டைப் பயன்படுத்துகிறோம். அதேசமயம் எண்ட்() சார்பு ஒரு மறு செய்கையை உருவாக்குகிறது. அதன் பிறகு, p_type ப்ரோமிட்டிலிருந்து ஒரு coroutine_handle ஐ உருவாக்குவதன் மூலம் உறுதிமொழி வகையை திரும்பப்பெற வாக்குறுதி() செயல்பாடு பயன்படுத்தப்படுகிறது. GenerateNumbers() செயல்பாடு என்பது co_yield முக்கிய சொல்லைப் பயன்படுத்தி - 5, 6 மற்றும் 7 ஆகிய மூன்று மதிப்புகளை வழங்கும் ஒரு கரோட்டின் ஆகும்.
பிரதான() செயல்பாட்டில், 'nc' என்ற பெயரிடப்பட்ட NEWCoroutine இன் நிகழ்வு, GeneralNumbers() coroutine ஐ செயல்படுத்துவதன் மூலம் உருவாக்கப்பட்டது. இது கரோட்டினைத் துவக்கி அதன் நிலையைப் பிடிக்கிறது. வரம்பு அடிப்படையிலான 'for' லூப் 'nc' இன் மதிப்புகளை மீண்டும் செய்ய பயன்படுத்தப்படுகிறது, மேலும் ஒவ்வொரு மதிப்பும் std::cout ஐப் பயன்படுத்தி இடைவெளியால் பிரிக்கப்படும்.
உருவாக்கப்பட்ட வெளியீடு பின்வருமாறு:
முடிவுரை
இந்த கட்டுரை C++ இல் கரோட்டின்களின் பயன்பாட்டை நிரூபிக்கிறது. நாங்கள் இரண்டு உதாரணங்களைப் பற்றி விவாதித்தோம். முதல் விளக்கத்திற்கு, கரோட்டின் செயல்பாடுகளைப் பயன்படுத்தி அடிப்படை கரோட்டின் C++ நிரலில் உருவாக்கப்படுகிறது. எண்களின் வரிசையை உருவாக்க ஜெனரேட்டர் போன்ற நடத்தையை உருவாக்க, அளவுருக்களுடன் கரோட்டின்களைப் பயன்படுத்துவதன் மூலம் இரண்டாவது ஆர்ப்பாட்டம் மேற்கொள்ளப்பட்டது.