C++ இல் மல்டித்ரெடிங் என்பது ஒரே நேரத்தில் பல பணிகளைச் செய்ய அனுமதிக்கும் ஒரு அம்சமாகும். ஒரு நூல் என்பது ஒரு குறிப்பிட்ட செயல்முறையின் செயல்பாட்டு அலகு ஆகும். மல்டித்ரெடிங்கைச் செய்ய எண்ணற்ற நூல்கள் ஒரே நேரத்தில் ஒன்றுக்கொன்று சுயாதீனமாக இயங்குகின்றன.
C++ இல் மல்டித்ரெடிங்கை எவ்வாறு செயல்படுத்துவது
ஒரு மல்டித்ரெட் நிரல் இரண்டு அல்லது அதற்கு மேற்பட்ட பகுதிகளைக் கொண்டுள்ளது, அவை ஒரே நேரத்தில் இயங்கும் போக்கைக் கொண்டுள்ளன, ஒவ்வொரு பகுதியும் ஒரு நூல் என்று அறியப்படுகிறது மற்றும் செயல்படுத்துவதற்கான வெவ்வேறு பாதையைக் கொண்டுள்ளது. மல்டித்ரெடிங்கைச் செய்ய எண்ணற்ற நூல்கள் ஒரே நேரத்தில் ஒன்றுக்கொன்று சுயாதீனமாக இயங்குகின்றன.
C++ இல் மல்டித்ரெடிங்கிற்கான முன்-தேவைகள்
விண்டோஸில், நூல்கள் தொடர்பான செயல்பாடுகளை C++ 11 மற்றும் மேம்பட்ட பதிப்புகளில் செய்ய முடியும். Dev-C++ கம்பைலரைப் பயன்படுத்தும் போது, இயல்பாக இது C++ 3 பதிப்பில் இருக்கும், எனவே இது C++ 11 பதிப்பிற்கு கைமுறையாக மாற்றப்பட வேண்டும். மொழி நிலையான அமைப்புகளை மாற்றுவதன் மூலம் GNU C++11 சூழலைத் தேர்ந்தெடுக்கலாம்.
Dev-C++ கம்பைலரைத் திறந்து, பணிப்பட்டியில் 'கருவிகள்' என்பதற்குச் செல்லவும். 'கம்பைலர் விருப்பங்கள்' என்பதைத் தேர்ந்தெடுத்து, பின்னர் 'அமைப்புகள்' என்பதைத் தேர்ந்தெடுத்து, 'கோட் ஜெனரேஷன்' பிளாக் என்பதைக் கிளிக் செய்யவும், கட்டளைகளின் பட்டியல் தோன்றும். “Language Standard(-std)” இலிருந்து GNU C++11 ஐத் தேர்ந்தெடுத்து சரி என்பதைக் கிளிக் செய்யவும். இப்போது இந்த கம்பைலர் நூல் செயல்பாடுகளை ஆதரிக்க தயாராக உள்ளது.
GitHub இலிருந்து நூலகங்களைப் பதிவிறக்கவும் மற்றும் அவற்றை Cpp கம்பைலரின் lib கோப்புறையில் வைக்கவும். #include “mingw.thread.h” மற்றும்
std:: thread thread_object ( அழைக்கக்கூடியது ) ;
std::thread ஆனது C++11ல் உள்ள #include “mingw.thread.h” தலைப்புக் கோப்பால் ஆதரிக்கப்படுகிறது. இது ஒரு நூல் வகுப்பு மற்றும் ஒற்றை நூலைக் குறிக்கிறது. std::thread ஐப் பயன்படுத்தி ஒரு புதிய நூல் உருவாக்கப்பட்டு அதற்கு ஒரு callable அனுப்பப்படும். Callable என்பது இயங்கக்கூடிய குறியீடாகும், இது நூல் இயங்கும் போது செயல்படுத்தப்படுகிறது. அழைக்கக்கூடியது கீழே கொடுக்கப்பட்டுள்ள மூன்று வகைகளில் ஏதேனும் இருக்கலாம்:
ஒரு பொருள் உருவாக்கப்படும் போது, அது ஒரு புதிய நூலைத் தொடங்குகிறது, அது அழைக்கக்கூடிய குறியீட்டை இயக்குகிறது.
செயல்பாட்டுப் பொருளைப் பயன்படுத்தி நூலின் துவக்கம்
ஒரு செயல்பாட்டுப் பொருளை நூலைத் தொடங்க அழைக்கக்கூடியதாகப் பயன்படுத்தலாம், ஓவர்லோட் ஆபரேட்டர் () அதை அழைக்கக்கூடியதாக ஆக்குகிறது:
வகுப்பு செயல்பாடு_பொருள்_வகுப்பு {வெற்றிட ஆபரேட்டர் ( ) ( அளவுருக்கள் )
{
அறிக்கைகள்;
}
}
std:: thread thread_object ( செயல்பாடு_பொருள்_வகுப்பு ( ) , params )
ஓவர்லோட் செயல்பாடு, கட்டமைப்பாளருக்கு முதல் பொருளாகவும், அறிக்கைகள் இரண்டாவது பொருளாகவும் வழங்கப்படுகிறது.
ஃபங்ஷன் பாயிண்டரைப் பயன்படுத்தி த்ரெட்டின் துவக்கம்
ஒரு செயல்பாடு சுட்டிக்காட்டி வரையறுக்கப்படுகிறது, பின்னர் அது ஒரு நூலைத் தொடங்க அழைக்கக்கூடியதாகப் பயன்படுத்தப்படுகிறது:
வெற்றிட செயல்பாடு_அழைப்பு ( பரம் ){
அறிக்கைகள்;
}
std::thread thread_obj ( செயல்பாடு_அழைப்பு, அளவுருக்கள் ) ;
நிறைவேற்றப்பட வேண்டிய வாதங்கள் செயல்பாட்டின் பெயருக்குப் பிறகு எழுதப்படுகின்றன.
லாம்ப்டா எக்ஸ்பிரஷனைப் பயன்படுத்தி நூலின் துவக்கம்
லாம்ப்டாவை அழைக்கக்கூடியதாகப் பயன்படுத்தி நூல் பொருளைத் தொடங்கலாம்.
// லாம்ப்டா வெளிப்பாட்டை வரையறுக்கவும்ஆட்டோ எஃப் = [ ] ( அளவுருக்கள் )
{
அறிக்கைகள்;
} ;
std:: thread thread_object ( f, அளவுருக்கள் ) ;
லாம்ப்டா வெளிப்பாடு வரையறுக்கப்பட்டுள்ளது, மேலும் நூலைத் தொடங்க அளவுருக்கள் அதில் அழைக்கப்படுகின்றன.
சில சமயங்களில், அடுத்த கட்டளையை இயக்கத் தொடங்கும் முன் நூல் நிறுத்தப்பட வேண்டும். தி std::thread:: join () நூல் முடிவடையும் வரை காத்திருக்க செயல்பாடு பயன்படுத்தப்படுகிறது. எடுத்துக்காட்டாக, த்ரெட்டிற்கு GUI இன் பணியை நாம் ஒதுக்கினால், முதலில் GUI ஐ சரியாக ஏற்றுவதற்கு அதன் முடிவடையும் வரை காத்திருக்க வேண்டும், அதன் பிறகு அடுத்த கட்டளையை செயல்படுத்த வேண்டும்.
முழு எண்ணாக ( ){
std::thread t1 ( அழைக்கக்கூடியது ) ;
t1.சேர்க ( ) ;
அறிக்கைகள்;
}
உதாரணமாக
இது மூன்று அழைக்கக்கூடிய மல்டித்ரெடிங்கைப் பயன்படுத்தி செயல்படுத்தப்படும் ஒரு நிரலாகும். மூன்று வெவ்வேறு அழைக்கக்கூடியது தங்களுக்குரிய கட்டளைகளை ஒன்றுக்கொன்று குறுக்கிடாமல் ஒரே நேரத்தில் மூன்று முறை செயல்படுத்துகிறது:
##
பெயர்வெளி std ஐப் பயன்படுத்துதல்;
வெற்றிடத்தை foo ( int Z )
{
க்கான ( int i = 0 ; நான் < Z; நான்++ ) {
கூட் << 'செயல்பாட்டைப் பயன்படுத்தி நூல்'
'அழைக்கக்கூடிய சுட்டி \n ' ;
}
}
வகுப்பு நூல்_obj {
பொது:
வெற்றிட ஆபரேட்டர் ( ) ( முழு எண்ணாக x )
{
க்கான ( int i = 0 ; நான் < எக்ஸ்; நான்++ )
கூட் << 'செயல்பாட்டைப் பயன்படுத்தி நூல்'
'அழைக்கக்கூடிய பொருள் \n ' ;
}
} ;
// முக்கிய குறியீடு
முழு எண்ணாக ( )
{
கூட் << 'இழைகள் 1 மற்றும் 2 மற்றும் 3'
'சுதந்திரமாக செயல்படும்'
<< endl;
நூல் th1 ( foo, 3 ) ;
நூல் th2 ( நூல்_பொருள் ( ) , 3 ) ;
ஆட்டோ எஃப் = [ ] ( முழு எண்ணாக x ) {
க்கான ( int i = 0 ; நான் < எக்ஸ்; நான்++ )
கூட் << 'லாம்ப்டாவைப் பயன்படுத்தி நூல்'
'அழைக்கக்கூடிய வெளிப்பாடு \n ' ;
} ;
நூல் th3 ( f, 3 ) ;
th1.join ( ) ;
th2.join ( ) ;
th3.join ( ) ;
திரும்ப 0 ;
}
இந்த நிரலில், செயல்பாடு சுட்டிக்காட்டி, செயல்பாட்டு பொருள் மற்றும் லாம்ப்டா வெளிப்பாடு உள்ளிட்ட மூன்று அழைக்கக்கூடிய மூன்று நூல்கள் ஒரே நேரத்தில் தொடங்குவதற்குப் பயன்படுத்தப்படுகின்றன. இழைகள் 1, 2 மற்றும் 3 ஒன்றுடன் ஒன்று குறுக்கிடாமல், அவற்றின் மதிப்புகளை ஒரே நேரத்தில் அச்சிடுகின்றன. அவர்கள் தங்கள் மதிப்புகளை மூன்று முறை அச்சிடுகிறார்கள். திரி முடிவடையும் வரை காத்திருக்க, join() செயல்பாடு பயன்படுத்தப்படுகிறது.
மூன்று நூல்களின் வெளியீடுகளும் தனித்தனியாகக் காட்டப்பட்டு மூன்று முறை மீண்டும் மீண்டும் செய்யப்படுகின்றன. ஒவ்வொரு இழையும் மற்றொன்று முதலில் முடிவடையும் வரை காத்திருக்கிறது.
முடிவுரை
C++ இல் மல்டித்ரெடிங் என்பது ஒரே நேரத்தில் பல பணிகளைச் செய்ய அனுமதிக்கும் ஒரு அம்சமாகும். மல்டித்ரெட் நிரல் ஒரே நேரத்தில் இயங்கக்கூடிய இரண்டு அல்லது அதற்கு மேற்பட்ட பிரிவுகளைக் கொண்டுள்ளது, ஒவ்வொரு பகுதியும் ஒரு நூல் என அறியப்படுகிறது மற்றும் செயல்படுத்துவதற்கு ஒரு தனி பாதை உள்ளது. த்ரெட்கள், செயல்பாட்டு சுட்டிகள், செயல்பாட்டு பொருள்கள் மற்றும் லாம்ப்டா வெளிப்பாடுகள் தொடங்க மூன்று அழைக்கக்கூடியவை உள்ளன. இவை மல்டித்ரெடிங்கை செயல்படுத்துகின்றன.