C++లో మల్టీథ్రెడింగ్ అనేది ఒక వ్యక్తి ఏకకాలంలో బహుళ విధులను నిర్వహించడానికి అనుమతించే లక్షణం. థ్రెడ్ అనేది ఒక నిర్దిష్ట ప్రక్రియ యొక్క పని యూనిట్. బహుళ థ్రెడింగ్‌ని నిర్వహించడానికి అనేక థ్రెడ్లు ఒకే సమయంలో ఒకదానికొకటి స్వతంత్రంగా అమలు చేయబడతాయి.
C++లో మల్టీథ్రెడింగ్‌ని ఎలా అమలు చేయాలి
మల్టీథ్రెడ్ ప్రోగ్రామ్ రెండు లేదా అంతకంటే ఎక్కువ భాగాలను కలిగి ఉంటుంది, అవి ఏకకాలంలో అమలు చేసే ధోరణిని కలిగి ఉంటాయి, ప్రతి భాగాన్ని థ్రెడ్ అని పిలుస్తారు మరియు అమలు చేయడానికి వేరే మార్గం ఉంటుంది. బహుళ థ్రెడింగ్‌ని నిర్వహించడానికి అనేక థ్రెడ్లు ఒకే సమయంలో ఒకదానికొకటి స్వతంత్రంగా అమలు చేయబడతాయి.
C++లో మల్టీథ్రెడింగ్ కోసం ముందస్తు అవసరాలు
Windowsలో, థ్రెడ్‌లకు సంబంధించిన విధులు C++ 11 మరియు అధునాతన సంస్కరణల్లో నిర్వహించబడతాయి. Dev-C++ కంపైలర్‌ని ఉపయోగిస్తున్నప్పుడు, డిఫాల్ట్‌గా ఇది C++ 3 వెర్షన్‌లో ఉంటుంది, కాబట్టి దీన్ని C++ 11 వెర్షన్‌కి మాన్యువల్‌గా మార్చాలి. GNU C++11 ఎన్విరాన్మెంట్ లాంగ్వేజ్ స్టాండర్డ్ సెట్టింగులను మార్చడం ద్వారా ఎంచుకోవచ్చు.
Dev-C++ కంపైలర్‌ని తెరిచి, టాస్క్‌బార్‌లోని 'టూల్స్'కి వెళ్లండి. “కంపైలర్ ఎంపికలు” ఎంచుకుని, ఆపై “సెట్టింగ్‌లు” ఎంచుకుని, “కోడ్ జనరేషన్” బ్లాక్‌పై క్లిక్ చేసి ఆదేశాల జాబితా కనిపిస్తుంది. “Language Standard(-std)” నుండి GNU C++11ని ఎంచుకుని, ఆపై సరి క్లిక్ చేయండి. ఇప్పుడు ఈ కంపైలర్ థ్రెడ్ కార్యకలాపాలకు మద్దతు ఇవ్వడానికి సిద్ధంగా ఉంది.
GitHub నుండి లైబ్రరీలను డౌన్‌లోడ్ చేయండి మరియు వాటిని Cpp కంపైలర్ యొక్క లిబ్ ఫోల్డర్‌లో ఉంచండి. #include “mingw.thread.h” మరియు
std::thread thread_object ( పిలవదగినది ) ;
std::threadకి C++11లో #include “mingw.thread.h” హెడర్ ఫైల్ మద్దతు ఇస్తుంది. ఇది థ్రెడ్ క్లాస్ మరియు ఒకే థ్రెడ్‌ను సూచిస్తుంది. std::threadని ఉపయోగించి కొత్త థ్రెడ్ సృష్టించబడింది మరియు దానికి కాల్ చేయదగినది పంపబడుతుంది. కాల్ చేయదగినది ఎక్జిక్యూటబుల్ కోడ్, ఇది థ్రెడ్ నడుస్తున్నప్పుడు అమలు చేయబడుతుంది. క్రింద ఇవ్వబడిన మూడు రకాలలో ఏదైనా కాల్ చేయవచ్చు:
ఒక వస్తువు సృష్టించబడినప్పుడు, అది కొత్త థ్రెడ్‌ను ప్రారంభిస్తుంది, అది కాల్ చేయదగిన కోడ్‌ను అమలు చేస్తుంది.
ఫంక్షన్ ఆబ్జెక్ట్ ఉపయోగించి థ్రెడ్ ప్రారంభించండి
థ్రెడ్‌ను ప్రారంభించడానికి ఒక ఫంక్షన్ ఆబ్జెక్ట్‌ని కాల్ చేయదగినదిగా ఉపయోగించవచ్చు, ఓవర్‌లోడ్ ఆపరేటర్ () దానిని కాల్ చేయదగినదిగా చేస్తుంది:
తరగతి ఫంక్షన్_ఆబ్జెక్ట్_క్లాస్ {శూన్యమైన ఆపరేటర్ ( ) ( పారాములు )
{
ప్రకటనలు;
}
}
std::thread thread_object ( ఫంక్షన్_ఆబ్జెక్ట్_క్లాస్ ( ) , పారాములు )
ఓవర్‌లోడ్ ఫంక్షన్ కన్స్ట్రక్టర్‌కు మొదటి వస్తువుగా మరియు స్టేట్‌మెంట్‌లు రెండవ వస్తువుగా అందించబడుతుంది.
ఫంక్షన్ పాయింటర్ ఉపయోగించి థ్రెడ్ ప్రారంభించండి
ఒక ఫంక్షన్ పాయింటర్ నిర్వచించబడింది మరియు ఇది థ్రెడ్‌ను ప్రారంభించడానికి కాల్ చేయదగినదిగా ఉపయోగించబడుతుంది:
శూన్యం ఫంక్షన్_కాల్ ( పరమం ){
ప్రకటనలు;
}
std::thread thread_obj ( ఫంక్షన్_కాల్, పారామ్స్ ) ;
ఆమోదించవలసిన వాదనలు ఫంక్షన్ పేరు తర్వాత వ్రాయబడతాయి.
లాంబ్డా ఎక్స్‌ప్రెషన్‌ని ఉపయోగించి థ్రెడ్ ప్రారంభం
థ్రెడ్ వస్తువు లాంబ్డాను కాల్ చేయదగినదిగా ఉపయోగించి ప్రారంభించవచ్చు.
// లాంబ్డా వ్యక్తీకరణను నిర్వచించండిఆటో f = [ ] ( పారాములు )
{
ప్రకటనలు;
} ;
std::thread thread_object ( f, పారామ్స్ ) ;
లాంబ్డా వ్యక్తీకరణ నిర్వచించబడింది మరియు థ్రెడ్‌ను ప్రారంభించడానికి పారామితులను అందులో పిలుస్తారు.
కొన్ని సందర్భాల్లో, థ్రెడ్ తదుపరి ఆదేశాన్ని అమలు చేయడం ప్రారంభించే ముందు ఆపివేయాలి. ది std::thread:: join () థ్రెడ్ ముగిసే వరకు వేచి ఉండటానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఉదాహరణకు, మేము థ్రెడ్‌కు GUI యొక్క టాస్క్‌ను కేటాయించినట్లయితే, ముందుగా GUIని సరిగ్గా లోడ్ చేయడానికి దాని ముగింపు సమయం కోసం వేచి ఉండాలి మరియు తర్వాత తదుపరి ఆదేశాన్ని అమలు చేయడం జరుగుతుంది.
పూర్ణాంక ప్రధాన ( ){
std::థ్రెడ్ t1 ( పిలవదగినది ) ;
t1.చేరండి ( ) ;
ప్రకటనలు;
}
ఉదాహరణ
ఇది మూడు కాల్ చేయదగినవి ఉపయోగించి మల్టీథ్రెడింగ్ చేయడం కోసం అమలు చేయబడిన ప్రోగ్రామ్. మూడు వేర్వేరు కాల్ చేయదగినవి ఒకదానికొకటి అంతరాయం కలగకుండా వాటి సంబంధిత ఆదేశాలను ఏకకాలంలో మూడుసార్లు అమలు చేస్తాయి:
##<థ్రెడ్> చేర్చండి
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
శూన్యం foo ( int Z )
{
కోసం ( int i = 0 ; i < Z; i++ ) {
కోట్ << 'థ్రెడ్ ఉపయోగించి ఫంక్షన్'
' పిలవదగినదిగా పాయింటర్ \n ' ;
}
}
తరగతి థ్రెడ్_obj {
ప్రజా:
శూన్యమైన ఆపరేటర్ ( ) ( int x )
{
కోసం ( int i = 0 ; i < x; i++ )
కోట్ << 'థ్రెడ్ ఉపయోగించి ఫంక్షన్'
'ఆబ్జెక్ట్ కాల్ చేయదగినది \n ' ;
}
} ;
// ప్రధాన కోడ్
పూర్ణాంక ప్రధాన ( )
{
కోట్ << 'థ్రెడ్లు 1 మరియు 2 మరియు 3'
'స్వతంత్రంగా పనిచేయడం'
<< endl;
థ్రెడ్ th1 ( foo, 3 ) ;
థ్రెడ్ th2 ( దారం_వస్తువు ( ) , 3 ) ;
ఆటో f = [ ] ( int x ) {
కోసం ( int i = 0 ; i < x; i++ )
కోట్ << 'లాంబ్డా ఉపయోగించి థ్రెడ్'
'అని పిలవబడే వ్యక్తీకరణ \n ' ;
} ;
థ్రెడ్ th3 ( f, 3 ) ;
th1. join ( ) ;
th2.join ( ) ;
th3.చేరండి ( ) ;
తిరిగి 0 ;
}
ఈ ప్రోగ్రామ్‌లో మూడు థ్రెడ్‌లను ఏకకాలంలో ప్రారంభించేందుకు ఫంక్షన్ పాయింటర్, ఫంక్షన్ ఆబ్జెక్ట్ మరియు లాంబ్డా ఎక్స్‌ప్రెషన్‌తో సహా మూడు కాల్ చేయదగినవి ఉపయోగించబడతాయి. థ్రెడ్లు 1, 2 మరియు 3 వాటి విలువలను ఒకదానికొకటి అంతరాయం కలగకుండా ఏకకాలంలో ప్రింట్ చేస్తాయి. వారు తమ విలువలను మూడుసార్లు ముద్రిస్తారు. థ్రెడ్ ముగిసే వరకు వేచి ఉండటానికి join() ఫంక్షన్ ఉపయోగించబడుతుంది.
మూడు థ్రెడ్‌ల అవుట్‌పుట్‌లు స్వతంత్రంగా చూపబడతాయి మరియు మూడుసార్లు పునరావృతమవుతాయి. ప్రతి థ్రెడ్ మరొకటి ముందుగా ముగిసే వరకు వేచి ఉంటుంది.
ముగింపు
C++లో మల్టీథ్రెడింగ్ అనేది ఒక వ్యక్తి ఏకకాలంలో బహుళ విధులను నిర్వహించడానికి అనుమతించే లక్షణం. మల్టీథ్రెడ్ ప్రోగ్రామ్‌లో ఏకకాలంలో అమలు చేయగల రెండు లేదా అంతకంటే ఎక్కువ విభాగాలు ఉన్నాయి, ప్రతి భాగాన్ని థ్రెడ్ అని పిలుస్తారు మరియు అమలు కోసం ప్రత్యేక మార్గం ఉంటుంది. థ్రెడ్లు, ఫంక్షన్ పాయింటర్లు, ఫంక్షన్ ఆబ్జెక్ట్‌లు మరియు లాంబ్డా ఎక్స్‌ప్రెషన్‌లను లాంచ్ చేయడానికి మూడు కాల్ చేయదగినవి ఉన్నాయి. ఇవి మల్టీథ్రెడింగ్‌ను ఎనేబుల్ చేస్తాయి.