మల్టీథ్రెడింగ్ ఒకే ప్రోగ్రామ్‌లో అనేక థ్రెడ్‌ల అమలు యొక్క భావన. C++ వంటి ప్రోగ్రామింగ్ లాంగ్వేజ్‌లలో ఇది చాలా ఉపయోగకరమైన ఫీచర్, ఎందుకంటే ఇది ఏకకాలంలో బహుళ కార్యకలాపాలను నిర్వహించడానికి మాకు వీలు కల్పిస్తుంది. C++లో, మల్టీథ్రెడింగ్ ద్వారా సాధించవచ్చు <థ్రెడ్> లైబ్రరీ, ఇది బహుళ థ్రెడ్‌లను సృష్టించడానికి, నిర్వహించడానికి మరియు నియంత్రించడానికి డెవలపర్‌లను అనుమతించే తరగతులు మరియు ఫంక్షన్‌ల సమితిని అందిస్తుంది.
మల్టీథ్రెడింగ్ బహువిధి వంటిది. రెండు లేదా అంతకంటే ఎక్కువ థ్రెడ్‌లు ఏకకాలంలో నడుస్తున్నాయని అర్థం. అటువంటి ప్రోగ్రామ్‌లో, ప్రతి భాగం థ్రెడ్‌గా సూచించబడుతుంది మరియు ప్రతి థ్రెడ్ అమలు యొక్క ప్రత్యేక మార్గాన్ని నిర్దేశిస్తుంది. దీనికి అంతర్నిర్మిత మద్దతు లేదు బహుళ థ్రెడ్ C++ 11కి ముందు ప్రోగ్రామ్‌లు. ఈ ఫీచర్ బదులుగా పూర్తిగా ఆపరేటింగ్ సిస్టమ్ ద్వారా అందించబడుతుంది.
మల్టీథ్రెడింగ్ ప్రోగ్రామ్‌ను ఏకకాలంలో అమలు చేసే చిన్న థ్రెడ్‌లుగా విభజించడం అని కూడా సూచించవచ్చు. థ్రెడ్ క్లాస్, దీని కోసం ఉపయోగించబడుతుంది మల్టీథ్రెడింగ్ C++లో, మీరు అనేక థ్రెడ్‌లను నిర్మించడానికి మరియు వాటి అమలును నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది.
C++లో థ్రెడ్‌లను సృష్టించండి
C++లో థ్రెడ్‌ని సృష్టించడానికి, మేము దీన్ని ఉపయోగిస్తాము std::థ్రెడ్ తరగతి, ఇది అంతర్నిర్మిత థ్రెడ్ లైబ్రరీలో చేర్చబడింది. ఎ పిలవదగినది తరగతి యొక్క వస్తువు యొక్క కన్స్ట్రక్టర్‌కు వాదనగా అందించబడుతుంది std::థ్రెడ్ కొత్త థ్రెడ్‌ని రూపొందించడానికి. థ్రెడ్ సక్రియంగా ఉన్నప్పుడు అమలు చేయబడిన కోడ్ అంటారు పిలవదగినది . మేము నిర్మించినప్పుడు a std::థ్రెడ్ ఆబ్జెక్ట్, ఒక కొత్త థ్రెడ్ స్థాపించబడింది, దీని వలన కోడ్ సరఫరా చేయబడుతుంది పిలవదగినది అమలు చేయాలి. పిలవదగినది ఈ మూడు పద్ధతులను ఉపయోగించి నిర్వచించవచ్చు.
విధానం 1: ఫంక్షన్ పాయింటర్
పిలవదగినది ఫంక్షన్ పాయింటర్‌ని ఉపయోగించి ఫంక్షన్‌లను ఇలా నిర్వచించవచ్చు.
శూన్యం ఫంక్షన్_కాల్ ( పారామితులు )
ఫంక్షన్ నిర్మించబడినప్పుడు, ఫంక్షన్‌ను కలిగి ఉన్న థ్రెడ్ ఆబ్జెక్ట్ క్రింది విధంగా ఉత్పత్తి చేయబడుతుంది:
std::thread thread_obj ( ఫంక్షన్_కాల్, పారామితులు ) ;
విధానం 2: ఫంక్షన్ ఆబ్జెక్ట్
ఫంక్షన్ ఆబ్జెక్ట్‌ని ఉపయోగిస్తున్నప్పుడు, మేము ఆపరేటర్ ఓవర్‌లోడింగ్ ఆలోచనను ఉపయోగించుకుంటాము. థ్రెడ్ ఏర్పడుతున్నప్పుడు తప్పనిసరిగా అమలు చేయవలసిన కోడ్ ఓవర్‌లోడ్ చేయబడిన ఫంక్షన్‌లో ఉంటుంది.
తరగతి ఆబ్జెక్ట్_క్లాస్ {శూన్యమైన ఆపరేటర్ ( ) ( పారామితులు )
{
// కోడ్ అమలు చేయాలి
}
} ;
std::thread thread_object ( ఆబ్జెక్ట్_క్లాస్ ( ) , పారామితులు )
విధానం 3: లాంబ్డా వ్యక్తీకరణ
పిలవదగినది లాంబ్డా వ్యక్తీకరణను ఉపయోగించి విధులు ఇలా నిర్వచించవచ్చు.
ఆటో f = [ ] ( పారామితులు ) {// కోడ్ అమలు చేయాలి
} ;
std::thread thread_object ( f, పారామితులు ) ;
C++లో మల్టీథ్రెడింగ్‌కు ఉదాహరణ
##<థ్రెడ్> చేర్చండి
నేమ్‌స్పేస్ stdని ఉపయోగించడం;
శూన్యమైన ఫంక్_థ్రెడ్ ( int N )
{
కోసం ( int i = 0 ; i < N; i++ ) {
కోట్ << 'థ్రెడ్ 1 :: కాల్ చేయదగిన => ఫంక్షన్ పాయింటర్‌ని ఉపయోగించడం \n ' ;
}
}
తరగతి థ్రెడ్_obj {
ప్రజా:
శూన్యమైన ఆపరేటర్ ( ) ( int n ) {
కోసం ( int i = 0 ; i < n; i++ )
కోట్ << 'థ్రెడ్ 2 :: కాల్ చేయదగిన => ఫంక్షన్ ఆబ్జెక్ట్‌ని ఉపయోగించడం \n ' ;
}
} ;
పూర్ణాంక ప్రధాన ( )
{
ఆటో f = [ ] ( int n ) {
కోసం ( int i = 0 ; i < n; i++ )
కోట్ << 'థ్రెడ్ 3 :: కాల్ చేయదగిన => లాంబ్డా వ్యక్తీకరణను ఉపయోగించడం \n ' ;
} ;
థ్రెడ్ th1 ( ఫంక్_థ్రెడ్, 2 ) ;
థ్రెడ్ th2 ( దారం_వస్తువు ( ) , 2 ) ;
థ్రెడ్ th3 ( f, 2 ) ;
th1.చేరండి ( ) ;
th2.join ( ) ;
th3.join ( ) ;
తిరిగి 0 ;
}
పై కోడ్‌లో, మేము మూడు వేర్వేరు థ్రెడ్‌లను అభివృద్ధి చేసాము కాల్ చేయదగినవి -ఒక ఫంక్షన్ పాయింటర్, ఒక వస్తువు మరియు లాంబ్డా వ్యక్తీకరణ. ప్రతి థ్రెడ్ రెండు వేర్వేరు ఉదాహరణలుగా ప్రారంభించబడింది. అవుట్‌పుట్‌లో సూచించిన విధంగా మూడు థ్రెడ్‌లు ఏకకాలంలో మరియు విడిగా చురుకుగా ఉంటాయి.
అవుట్‌పుట్
మల్టీథ్రెడింగ్ యొక్క ప్రయోజనాలు మరియు అప్రయోజనాలు
ధన్యవాదాలు మరింత పని త్వరగా చేయవచ్చు మల్టీథ్రెడింగ్ . ఎందుకంటే ఇది అనేక థ్రెడ్‌లను ఒకేసారి వివిధ పనులను నిర్వహించడానికి అనుమతిస్తుంది. మల్టీథ్రెడింగ్ ప్రోగ్రామర్‌లు నెట్‌వర్క్ కార్యకలాపాలు చేయడానికి, ఫోటోలు లేదా వీడియోలను ప్రాసెస్ చేయడానికి మరియు మిగిలిన అప్లికేషన్‌ను నెమ్మదించకుండా సంక్లిష్టమైన గణనలను నిర్వహించడానికి అనుమతిస్తుంది. మల్టీథ్రెడింగ్ వినియోగదారు ఇంటర్‌ఫేస్‌లను మరింత ప్రతిస్పందించేలా చేయడంలో సహాయపడుతుంది. ప్రత్యేక థ్రెడ్‌లో స్క్రీన్‌ను మార్చే కోడ్‌ని అమలు చేయడం ద్వారా, వినియోగదారు ఇన్‌పుట్‌కు ప్రతిస్పందించడం వంటి ఇతర పనులను నిర్వహించడానికి UI థ్రెడ్ ఉచితంగా ఉంచబడుతుంది. ఇది సున్నితమైన మరియు వేగవంతమైన వినియోగదారు ఇంటర్‌ఫేస్‌లకు దారితీస్తుంది.
అయితే, ఉపయోగించడానికి కొన్ని పరిమితులు ఉన్నాయి మల్టీథ్రెడింగ్ . పని చేసేటప్పుడు ప్రధాన సవాళ్లలో ఒకటి బహుళ థ్రెడ్ కార్యక్రమాలు జాతి పరిస్థితులను నివారిస్తున్నాయి. రేస్ కండిషన్ అంటే రెండు లేదా అంతకంటే ఎక్కువ థ్రెడ్‌లు ఒకే సమయంలో ఒకే భాగస్వామ్య వనరును యాక్సెస్ చేయడానికి ప్రయత్నిస్తున్నప్పుడు, ఇది ఊహించలేని ప్రవర్తనకు దారి తీస్తుంది. జాతి పరిస్థితులను నివారించడానికి, డెవలపర్లు మ్యూటెక్స్, సెమాఫోర్స్ మరియు అడ్డంకులు వంటి సమకాలీకరణ పద్ధతులను ఉపయోగిస్తారు.
ముగింపు
మల్టీథ్రెడింగ్ ఇన్ C++ అనేది డెవలపర్లు ఏకకాలంలో బహుళ విధులను నిర్వహించగల ప్రోగ్రామ్‌లను రూపొందించడానికి అనుమతించే శక్తివంతమైన భావన. లైబ్రరీ అందించిన థ్రెడ్ తరగతిని ఉపయోగించడం ద్వారా, డెవలపర్లు బహుళ థ్రెడ్‌లను సృష్టించవచ్చు, నిర్వహించవచ్చు మరియు నియంత్రించవచ్చు. మల్టీథ్రెడింగ్ పనితీరును మెరుగుపరచడానికి, ప్రతిస్పందనను పెంచడానికి మరియు సిస్టమ్ వనరుల పరిమితులను అధిగమించడానికి ఉపయోగించవచ్చు. అయితే, పనిలో ఉన్న సవాళ్ల కారణంగా బహుళ థ్రెడ్ ప్రోగ్రామ్‌లు, డెవలపర్లు జాగ్రత్తగా ఉండాలి మరియు జాతి పరిస్థితులను నివారించడానికి తగిన సమకాలీకరణ పద్ధతులను ఉపయోగించాలి.