C ++ మంచి పనితీరు, అధిక ఖచ్చితత్వం మరియు తగిన మెమరీ మేనేజ్‌మెంట్ సిస్టమ్‌తో వేగవంతమైన ప్రోగ్రామింగ్ భాషలలో ఒకటిగా ప్రసిద్ధి చెందింది. ఈ ప్రోగ్రామింగ్ లాంగ్వేజ్ బహుళ థ్రెడ్‌ల మధ్య బహుళ వనరుల భాగస్వామ్యంతో ఏకకాలంలో అమలు చేయడానికి కూడా మద్దతు ఇస్తుంది. మల్టీథ్రెడింగ్‌లో, ఆ సమయంలో ఇతర థ్రెడ్‌లు ఏమి చేస్తున్నాయో థ్రెడ్ ప్రభావితం కానందున ఎటువంటి సమస్యలను కలిగించని రీడ్ ఆపరేషన్‌ను మాత్రమే థ్రెడ్ నిర్వహిస్తుంది. కానీ ఈ థ్రెడ్‌లు వాటి మధ్య వనరులను పంచుకోవాల్సి వస్తే, ఒక థ్రెడ్ ఆ సమయంలో డేటాను సవరించగలదు, ఇది సమస్యను చేస్తుంది. ఈ సమస్యను పరిష్కరించడానికి, మేము C++ “Mutex”ని కలిగి ఉన్నాము, ఇది ఆబ్జెక్ట్/కోడ్‌కు ప్రాప్యతను ఒకేసారి ఒక థ్రెడ్‌కు మాత్రమే అందించగలదని సూచించే సమకాలీకరణను అందించడం ద్వారా మా కోడ్/ఆబ్జెక్ట్‌కు బహుళ వనరుల యాక్సెస్‌ను నిరోధిస్తుంది. తద్వారా బహుళ థ్రెడ్‌లు ఆ వస్తువును ఏకకాలంలో యాక్సెస్ చేయలేరు.
విధానం:
మ్యూటెక్స్ లాక్‌ని ఉపయోగించి ఒకే సమయంలో ఆబ్జెక్ట్‌కి బహుళ థ్రెడ్‌ల యాక్సెస్‌ను ఎలా ఆపవచ్చో మేము తెలుసుకుంటాము. మేము మ్యూటెక్స్ లాక్ యొక్క సింటాక్స్ గురించి మాట్లాడుతాము, మల్టిపుల్ థ్రెడింగ్ అంటే ఏమిటి మరియు మ్యూటెక్స్ లాక్‌ని ఉపయోగించి బహుళ థ్రెడింగ్ వల్ల కలిగే సమస్యలను ఎలా ఎదుర్కోవచ్చు. అప్పుడు, మేము బహుళ థ్రెడింగ్ యొక్క ఉదాహరణను తీసుకుంటాము మరియు వాటిపై మ్యూటెక్స్ లాక్‌ని అమలు చేస్తాము.
సింటాక్స్:
మనం మ్యూటెక్స్ లాక్‌ని ఎలా అమలు చేయవచ్చో తెలుసుకోవాలనుకుంటే, తద్వారా మన వస్తువు లేదా కోడ్‌కి ఏకకాలంలో బహుళ థ్రెడ్‌ల యాక్సెస్‌ను నిరోధించవచ్చు, మేము క్రింది వాక్యనిర్మాణాన్ని ఉపయోగించవచ్చు:
$ స్టడీ :: మ్యూటెక్స్ mut_x
$mut_x. తాళం వేయండి ( ) ;
ఫంక్_పేరు శూన్యం ( ) {
$ // మేము బహుళ థ్రెడ్‌ల నుండి దాచాలనుకుంటున్న కోడ్ ఇక్కడ వ్రాయబడుతుంది
$mut_x. అన్‌లాక్ చేస్తుంది ( ) ;
}
మేము ఇప్పుడు ఈ సింటాక్స్‌ని డమ్మీ ఉదాహరణలో మరియు సూడో కోడ్‌లో ఉపయోగిస్తాము (కోడ్ ఎడిటర్‌లో ఉన్నట్లుగా మేము అమలు చేయలేము) ఈ క్రింది వాటిలో పేర్కొన్న విధంగా మేము ఈ సింటాక్స్‌ని సరిగ్గా ఎలా ఉపయోగించవచ్చో మీకు తెలియజేయడానికి:
$ స్టడీ :: మ్యూటెక్స్ mut_x
శూన్య బ్లాక్ ( ) {
$mut_x. తాళం వేయండి ( ) ;
$ స్టడీ :: కోట్ << 'హలో' ;
$mut_x. అన్‌లాక్ చేస్తుంది ( ) ;
}
ఉదాహరణ:
ఈ ఉదాహరణలో, ముందుగా మల్టీథ్రెడ్ ఆపరేషన్‌ని సృష్టించడానికి ప్రయత్నిద్దాం మరియు ఈ ఆపరేషన్‌ను మ్యూటెక్స్ లాక్‌తో చుట్టుముట్టండి మరియు సృష్టించిన కోడ్ లేదా ఆబ్జెక్ట్‌కు ఆపరేషన్ యొక్క సమకాలీకరణను అందించడానికి అన్‌లాక్ చేయండి. మ్యూటెక్స్ జాతి పరిస్థితులతో వ్యవహరిస్తుంది, ఇవి చాలా అనూహ్యమైన విలువలు మరియు అవి సమయ స్పృహతో ఉండే థ్రెడ్‌ల మార్పిడిపై ఆధారపడి ఉంటాయి. మ్యూటెక్స్ కోసం ఉదాహరణను అమలు చేయడానికి, మేము ముందుగా రిపోజిటరీల నుండి ముఖ్యమైన మరియు అవసరమైన లైబ్రరీలను దిగుమతి చేసుకోవాలి. అవసరమైన లైబ్రరీలు:
$ #
$ # <థ్రెడ్> ఉన్నాయి
$ #
“iostream” లైబ్రరీ మాకు డేటాను Coutగా ప్రదర్శించడానికి, డేటాను Cinగా చదవడానికి మరియు ప్రకటనను endlగా ముగించడానికి ఒక ఫంక్షన్‌ను అందిస్తుంది. థ్రెడ్‌ల నుండి ప్రోగ్రామ్‌లు లేదా ఫంక్షన్‌లను ఉపయోగించుకోవడానికి మేము “థ్రెడ్” లైబ్రరీని ఉపయోగిస్తాము. 'మ్యూటెక్స్' లైబ్రరీ మ్యూటెక్స్ లాక్ మరియు అన్‌లాక్ రెండింటినీ కోడ్‌లో అమలు చేయడానికి అనుమతిస్తుంది. ఇది కోడ్‌లో చేర్చబడిన లైబ్రరీకి సంబంధించిన అన్ని ప్రోగ్రామ్‌లను అనుమతిస్తుంది కాబట్టి మేము “# చేర్చండి”ని ఉపయోగిస్తాము.
ఇప్పుడు, మునుపటి దశ పూర్తయిన తర్వాత, మేము stdని ఉపయోగించి మ్యూటెక్స్ క్లాస్ లేదా మ్యూటెక్స్ కోసం గ్లోబల్ వేరియబుల్‌ని నిర్వచించాము. అప్పుడు, మేము మ్యూటెక్స్ లాక్ మరియు అన్‌లాక్ కోసం ఒక ఫంక్షన్‌ను సృష్టిస్తాము, దానిని మనం కోడ్‌లో కాల్ చేయవచ్చు. ఈ ఉదాహరణలో, మేము ఈ ఫంక్షన్‌కు బ్లాక్ అని పేరు పెట్టాము. బ్లాక్ ఫంక్షన్ యొక్క శరీరంలో, మేము మొదట 'mutex.lock()' అని పిలుస్తాము మరియు కోడ్ యొక్క తర్కాన్ని వ్రాయడం ప్రారంభించండి.
mutex.lock() మేము సృష్టించిన వస్తువు లేదా కోడ్‌ను చేరుకోవడానికి ఇతర థ్రెడ్‌ల యాక్సెస్‌ను నిరాకరిస్తుంది, తద్వారా ఒక థ్రెడ్ మాత్రమే మన వస్తువును ఒకేసారి చదవగలదు. లాజిక్‌లో, మేము 0 నుండి 9 వరకు ఇండెక్స్‌లో రన్ అయ్యే లూప్ కోసం రన్ చేస్తాము. మేము లూప్‌లో విలువలను ప్రదర్శిస్తాము. మ్యూటెక్స్ లాక్‌లో ఈ లాజిక్ సృష్టించబడిన తర్వాత దాని ఆపరేషన్ పూర్తయిన తర్వాత లేదా లాజిక్ నుండి నిష్క్రమించిన తర్వాత, మేము “mutex.unlock()” పద్ధతిని పిలుస్తాము. ఈ మెథడ్ కాల్ మ్యూటెక్స్ లాక్ నుండి సృష్టించబడిన ఆబ్జెక్ట్‌ను అన్‌లాక్ చేయడానికి అనుమతిస్తుంది, ఎందుకంటే ఒక సింగిల్ థ్రెడ్‌కు ఆబ్జెక్ట్ యాక్సెస్ ఇంతకు ముందు అందించబడింది మరియు ఆ వస్తువుపై ఆపరేషన్ ఒకసారి ఒక థ్రెడ్ ద్వారా చేయబడుతుంది. మేము ఇప్పుడు ఇతర థ్రెడ్‌లు కూడా ఆ వస్తువు లేదా కోడ్‌ని యాక్సెస్ చేయాలని కోరుకుంటున్నాము. లేకపోతే, మ్యూటెక్స్‌తో సృష్టించబడిన ఆబ్జెక్ట్ ఎప్పటికీ లాక్ చేయబడిన పరిస్థితిలో ఉండేలా చేసే “డెడ్‌లాక్” పరిస్థితిలో మా కోడ్ కదులుతుంది మరియు ఏ ఇతర థ్రెడ్ ఆ వస్తువును యాక్సెస్ చేయదు. అందువల్ల, అసంపూర్ణమైన ఆపరేషన్ అమలులో ఉంటుంది. దీని తరువాత, మేము బ్లాక్ ఫంక్షన్ నుండి నిష్క్రమించి, ప్రధానానికి వెళ్తాము.
ప్రధానంగా, మేము థ్రెడ్1, థ్రెడ్2 మరియు థ్రెడ్3 మొదలైన పేర్లతో 'std :: థ్రెడ్ థ్రెడ్_నేమ్ (ఇప్పటికే సృష్టించిన బ్లాక్ ఫంక్షన్‌ని ఇక్కడ సృష్టించిన మ్యూటెక్స్‌ని ఇక్కడ కాల్ చేయడం)' ఉపయోగించి మూడు థ్రెడ్‌లను సృష్టించడం ద్వారా మేము సృష్టించిన మ్యూటెక్స్‌ని ప్రదర్శిస్తాము. ఈ విధంగా, మూడు థ్రెడ్‌లు సృష్టించబడతాయి. మేము 'thread_name' అని పిలవడం ద్వారా ఏకకాలంలో అమలు చేయడానికి ఈ మూడు థ్రెడ్‌లను కలుపుతాము. చేరండి ()” పద్ధతి. ఆపై, మేము సున్నాకి సమానమైన విలువను తిరిగి ఇస్తాము. ఉదాహరణ యొక్క గతంలో పేర్కొన్న వివరణ క్రింది చిత్రంలో చూపబడే కోడ్ రూపంలో అమలు చేయబడుతుంది:
కోడ్ యొక్క అవుట్‌పుట్‌లో, మేము మూడు థ్రెడ్‌ల అమలు మరియు ప్రదర్శనను ఒక్కొక్కటిగా చూడవచ్చు. మన అప్లికేషన్ మల్టీథ్రెడింగ్ కేటగిరీ కిందకు వచ్చినా మనం చూడవచ్చు. అయినప్పటికీ, 'ఫంక్షన్ బ్లాక్' యొక్క మ్యూటెక్స్ అమలు కారణంగా థ్రెడ్‌లు ఏవీ ఓవర్‌రైట్ చేయలేదు లేదా డేటాను సవరించలేదు మరియు సవరించిన వనరును భాగస్వామ్యం చేయలేదు.
ముగింపు
ఈ గైడ్ C++లో ఉపయోగించిన మ్యూటెక్స్ ఫంక్షన్ యొక్క భావన యొక్క వివరణాత్మక వివరణను అందిస్తుంది. మల్టీథ్రెడింగ్ అప్లికేషన్‌లు ఏమిటి, మల్టీథ్రెడింగ్ అప్లికేషన్‌లలో మనం ఎలాంటి సమస్యలను ఎదుర్కోవాలి మరియు మల్టీథ్రెడింగ్ అప్లికేషన్‌ల కోసం మ్యూటెక్స్‌ను ఎందుకు అమలు చేయాలి అనే విషయాలను మేము చర్చించాము. మేము నకిలీ కోడ్‌ని ఉపయోగించి నకిలీ ఉదాహరణతో మ్యూటెక్స్ కోసం సింటాక్స్ గురించి చర్చించాము. అప్పుడు, మేము C++ విజువల్ స్టూడియోలో మ్యూటెక్స్‌తో మల్టీథ్రెడింగ్ అప్లికేషన్‌లపై పూర్తి ఉదాహరణను అమలు చేసాము.