“ప్రతి ప్రోగ్రామింగ్ భాష నిర్దిష్ట ప్రయోజనాల కోసం అనేక లైబ్రరీలను కలిగి ఉన్నప్పటికీ, C యొక్క POSIX లైబ్రరీ దాని స్థానాన్ని కలిగి ఉంది. ఇది ప్రక్రియల మధ్య గొప్ప సమన్వయాన్ని సృష్టించడానికి రూపొందించబడింది మరియు ప్రోగ్రామ్‌లలో మల్టీథ్రెడింగ్‌ను ఉపయోగించడంలో చాలా సహాయపడుతుంది, అనగా, బహుళ థ్రెడ్‌లను సృష్టించడం మరియు వాటి అమలును సమకాలీకరించడం. ఈ రోజు ఈ గైడ్‌లో, మీరు C లో POSIX సెమాఫోర్‌లను ఉపయోగించడం యొక్క సాధారణ ఉదాహరణను చూస్తారు. ప్రాథమిక C కోడ్ ఉదాహరణల కోసం, మేము సిస్టమ్‌లో దాని కంపైలర్‌ను తప్పనిసరిగా కాన్ఫిగర్ చేయాలి. కానీ, దానికి ముందు, కోడ్‌ని సజావుగా అమలు చేయడానికి ఇది తప్పనిసరిగా అవసరమైన దశ కాబట్టి మేము సిస్టమ్‌ను అప్‌డేట్ చేయాలి. అందువల్ల, జోడించిన స్నాప్‌లో ప్రదర్శించబడే ప్రశ్న తప్పనిసరిగా మీ Linux ఆపరేటింగ్ సిస్టమ్‌ను “apt” యుటిలిటీతో నవీకరించడానికి మరియు అప్‌గ్రేడ్ చేయడానికి తప్పనిసరిగా ఉండాలి.
నవీకరణలను సజావుగా నిర్వహించడానికి ఈ ప్రక్రియకు మీ Linux ప్లాట్‌ఫారమ్‌లో దాదాపు 55 Kb స్థలం అవసరం. మీరు అంత స్థలాన్ని ఇవ్వడానికి సిద్ధంగా ఉంటే, కొనసాగించడానికి “y” నొక్కండి. కొన్ని నిమిషాల్లో ప్రాసెసింగ్ పూర్తవుతుంది.
సిస్టమ్ పూర్తిగా అప్‌గ్రేడ్ అయిన తర్వాత, మన సిస్టమ్‌లోని సి భాష యొక్క కంపైలర్‌ను “ఇన్‌స్టాల్” కమాండ్‌లోని apt-get యుటిలిటీతో కాన్ఫిగర్ చేయబోతున్నాము. “gcc”ని కీవర్డ్‌గా ఉపయోగించండి మరియు అంతే.
సెమ్_ఇనిట్()
's' వద్ద ఇప్పటికే గుర్తించబడని సెమాఫోర్ ఉన్నప్పుడు తాజా సెమాఫోర్ సృష్టించబడుతుంది; లేకుంటే, ఇప్పటికే ఉన్న సెమాఫోర్ విస్మరించబడుతుంది. ఈ పద్ధతి మొత్తంలో, “s” అనేది నిర్మించబడిన సెమాఫోర్ ఉదాహరణని సూచిస్తుంది మరియు షేర్డ్ అనేది ఒక సిగ్నల్ లేదా పెనెంట్, ఇది సెమాఫోర్‌ను ఫోర్క్డ్() పద్ధతితో పంపిణీ చేయవచ్చా లేదా అనే విషయాన్ని సూచిస్తుంది. ఇన్‌పుట్ విలువ సెమాఫోర్ సెట్ బిగినింగ్ పాయింట్‌గా పనిచేస్తుంది.
Int sem_init ( కాదు_టి * s, int షేర్డ్, సైన్ చేయని పూర్ణాంక విలువ ) ;
సెమ్_వెయిట్()
's' ద్వారా పేర్కొనబడిన సెమాఫోర్‌పై సెమాఫోర్ లాక్ చర్యను అమలు చేయడం ద్వారా, sem_wait() పద్ధతి ఆ సెమాఫోర్‌ను కలిగి ఉంటుంది. సెమ్-వెయిట్ విధానం సెమాఫోర్‌ను నిలుపుకోవడానికి లేదా లైన్‌లో నిలబడటానికి ఉపయోగించబడుతుంది. కొన్ని ఇతర ప్రక్రియలు sem_post()ను ప్రారంభించినప్పుడు మునుపు ఓవర్‌లోడ్ చేయబడిన కొన్ని ప్రక్రియలు మేల్కొంటాయి.
పూర్ణ సెమ్_వెయిట్ ( కాదు_టి * లు ) ;
no_post()
సెమ్ పోస్ట్ అని పిలవబడినప్పుడు, విలువ పెరుగుతుంది, ఆపై గతంలో బ్యాకప్ చేయబడిన లేదా వేచి ఉన్న ఆపరేషన్‌లలో ఒకటి అమలు చేయడం ప్రారంభమవుతుంది, అనగా, ఇప్పటికే లాక్ చేయబడిన సెమాఫోర్‌ను అన్‌లాక్ చేస్తుంది.
పూర్ణ సెమ్_పోస్ట్ ( కాదు_టి * లు ) ;
no_destroy()
ప్రారంభించబడిన పేరులేని సెమాఫోర్ “s” sem నాశనం() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా నాశనం చేయబడుతుంది.
int sem_destroy ( కాదు_టి * లు ) ;
ఉదాహరణ
సెమాఫోర్‌లను అర్థం చేసుకోవడానికి, మేము ముందుగా C ఫైల్‌ని సృష్టించి, ఆపై దానికి కోడ్‌ని జోడించబోతున్నాము. ఒకదాన్ని సృష్టించడానికి, 'టచ్' ప్రశ్నను ఉపయోగించండి మరియు మీరు మీ సిస్టమ్ హోమ్ ఫోల్డర్‌లో కొత్త ఫైల్‌ను కనుగొంటారు.
ఇప్పుడు, మీరు మీ ఖాళీ సి ఫైల్‌లో మంచి కోడ్‌ని రూపొందించడానికి కొన్ని సాధారణ ఎడిటర్‌తో తెరవాలి. దిగువ స్నాప్‌లో చూపిన విధంగా మేము ఇప్పటివరకు “నానో” ఎడిటర్‌ని ప్రయత్నిస్తున్నాము.
లైబ్రరీలు లేకుండా అన్ని ప్రోగ్రామింగ్ భాషలు పని చేయలేవని మనందరికీ తెలుసు, ఎందుకంటే ఈ లైబ్రరీలు పెద్ద సంఖ్యలో తరగతులు, నిర్మాణాలు, విధులు మరియు మొత్తం సిస్టమ్ పని కోసం ఉపయోగించబడే వస్తువులను కలిగి ఉంటాయి. కాబట్టి మేము ఈ C ప్రోగ్రామ్‌ను POSIX సెమాఫోర్స్ కోసం కొన్ని ప్రాథమిక మరియు తప్పనిసరిగా కలిగి ఉండవలసిన లైబ్రరీలను ఉపయోగించడంతో ప్రారంభిస్తున్నాము.
కోడ్‌లో ఈ లైబ్రరీలను ఉపయోగించడానికి, మేము ప్రతి లైబ్రరీకి “ఇన్‌క్లూడ్” కీవర్డ్‌తో “#” అక్షరాన్ని ఉపయోగించాలి. ప్రస్తుతం, ఈ ప్రోగ్రామ్‌లో తప్పనిసరిగా ఉండాల్సిన మొత్తం 4 లైబ్రరీలను మేము జోడించాము. లేకపోతే, మా ప్రోగ్రామ్ సరిగ్గా పని చేయదు. మొదటి “stdio.h” హెడర్ లైబ్రరీ సాధారణంగా ప్రతి C ప్రోగ్రామ్‌లో తప్పనిసరిగా ఉండాలి ఎందుకంటే ఇది కోడ్‌లో ఇన్‌పుట్ మరియు అవుట్‌పుట్ కార్యకలాపాలను కలిగి ఉండటానికి అనుమతిస్తుంది. అందువల్ల, ఇన్‌పుట్‌లను సజావుగా జోడించడానికి మరియు కోడ్ నుండి అవుట్‌పుట్‌లను పొందడానికి మేము దీన్ని ఉపయోగిస్తున్నాము. మేము ఇక్కడ ఉపయోగిస్తున్న రెండవ లైబ్రరీ 'pthread.h', ఇది థ్రెడ్ ప్రోగ్రామింగ్ ఉపయోగం కోసం తప్పనిసరి, అంటే మల్టీథ్రెడింగ్.
మేము ప్రోగ్రామ్‌లో థ్రెడ్‌లను సృష్టించడానికి ఈ లైబ్రరీని ఉపయోగిస్తాము. ఈ కోడ్‌లోని తదుపరి మరియు అత్యంత ముఖ్యమైన లైబ్రరీ 'semaphore.h'. థ్రెడ్‌లను సజావుగా సమకాలీకరించడానికి ఇది ఉపయోగించబడింది. చివరిది కాని, లైబ్రరీ “unistd.h”, ఇది వినియోగదారు నిర్వచించిన ఇతర ఫంక్షన్‌లు మరియు స్థిరాంకాలను ఉపయోగించడానికి మాకు వీలు కల్పిస్తుంది. ఇప్పుడు, మేము సెమాఫోర్ లైబ్రరీ యొక్క 'sem_t' అంతర్నిర్మిత వస్తువును ఉపయోగించి 's' సెమాఫోర్‌ను ప్రకటించాము. ఇక్కడ థ్రెడ్ వినియోగదారు నిర్వచించిన ఫంక్షన్ “T” రిటర్న్ రకం లేకుండా వస్తుంది. ఇది సమకాలీకరణను నిర్వహించడానికి కొన్ని అంతర్నిర్మిత సెమాఫోర్ ఫంక్షన్‌లను ఉపయోగిస్తోంది. “&” అక్షరాన్ని ఉపయోగించి సెమాఫోర్ “s”ని పట్టుకోవడానికి sem_wait() ఫంక్షన్ ఇక్కడ ఉంది.
హోల్డ్‌లో, ఈ ప్రోగ్రామ్ 4 సెకన్లపాటు నిద్రపోయేలా చేయడానికి “స్లీప్” ఫంక్షన్‌తో పాటు printf() స్టేట్‌మెంట్ అమలు చేయబడింది. మరొక printf() ప్రకటన కొత్త సందేశాన్ని ప్రదర్శిస్తుంది మరియు సెమాఫోర్ “s”లో లాక్‌ని విడుదల చేయడానికి sem_post() ఫంక్షన్ అమలు చేయబడుతుంది.
##
#include
#
noither_t లు;
శూన్యం * టి ( శూన్యం * arg ) {
సెమ్_వెయిట్ ( & లు ) ;
printf ( 'స్వాగతం! \n ' ) ;
నిద్ర ( 4 ) ;
printf ( 'బై! \n ' ) ;
సెమ్_పోస్ట్ ( & లు ) ;
}
సెమాఫోర్స్ కోసం ఈ సి ప్రోగ్రామ్ యొక్క ప్రధాన () పద్ధతిని బాగా చూద్దాం. ఫోర్క్డ్() పద్ధతితో పంపిణీ చేయని కొత్త సెమాఫోర్ “s”ని సృష్టించడానికి sem_init() ఫంక్షన్ ఇక్కడ ఉపయోగించబడింది, అనగా “0”, మరియు దాని ప్రారంభ స్థానం 1కి సెట్ చేయబడింది. pthread నుండి pthread_t ఆబ్జెక్ట్ O1 మరియు o2 అనే రెండు థ్రెడ్ వస్తువులను ఉపయోగించి రెండు థ్రెడ్‌లను రూపొందించడానికి C యొక్క లైబ్రరీ ఉపయోగించబడింది. మేము pthread_create() ఫంక్షన్‌ని ఉపయోగించి మొదటి థ్రెడ్‌ను తదుపరి లైన్‌లో సృష్టించబోతున్నామని ప్రదర్శించడానికి printf() స్టేట్‌మెంట్ ఇక్కడ ఉంది.
మేము ఈ ఫంక్షన్‌కి O1 థ్రెడ్ ఆబ్జెక్ట్‌ను NULL పరిమితులతో పాస్ చేస్తున్నాము మరియు దానిని పారామితులలో పాస్ చేయడం ద్వారా ఫంక్షన్ “T” అని పిలుస్తున్నాము. 4 సెకన్ల నిద్ర తర్వాత, ఆబ్జెక్ట్ o2తో మరొక థ్రెడ్ సృష్టించబడింది మరియు ప్రధాన() ఫంక్షన్‌తో థ్రెడ్‌లను చేరడానికి pthread_join() ఫంక్షన్ ఇక్కడ ఉపయోగించబడుతుంది. 's' సెమాఫోర్‌ను నాశనం చేయడానికి sem_destroy() ఫంక్షన్ ఇక్కడ ఉంది మరియు బ్లాక్ చేయబడిన అన్ని థ్రెడ్‌లు కూడా విడుదల చేయబడతాయి.
పూర్ణాంక ప్రధాన ( ) {సెమ్_ఇనిట్ ( & లు, 0 , 1 ) ;
pthread_t o1, o2;
printf ( 'ఇప్పుడు 1వ థ్రెడ్‌లో... \n ' ) ;
pthread_create ( & o1,NULL,T,NULL ) ;
నిద్ర ( 4 ) ;
printf ( 'ఇప్పుడు 2వ థ్రెడ్‌లో... \n ' ) ;
pthread_create ( & o2,NULL,T,NULL ) ;
pthread_join ( o1, NULL ) ;
pthread_join ( o2, NULL ) ;
కాదు_నాశనం ( & లు ) ;
తిరిగి 0 ;
}
మేము 'Gcc' కంపైలర్‌తో C ప్రోగ్రామ్‌ను కంపైల్ చేస్తున్నాము; POSIX థ్రెడ్ ఫంక్షన్‌లను అమలు చేయడానికి “-lrt” మరియు “-lpthread” ఎంపికలు ఉపయోగించబడతాయి. “.a/.out” ప్రశ్నను అమలు చేస్తున్నప్పుడు, మొదటి థ్రెడ్ సృష్టించబడింది. ఇది మొదటి సందేశాన్ని ముద్రించిన తర్వాత నిద్రపోతుంది.
రెండవ థ్రెడ్ సమకాలీకరించబడింది మరియు 4 సెకన్ల తర్వాత, మొదటి థ్రెడ్ విడుదలైంది మరియు రెండవ థ్రెడ్ 4 సెకన్ల పాటు లాక్ చేయబడింది.
చివరికి, రెండవ థ్రెడ్ కూడా విడుదలైంది.
ముగింపు
వివిధ థ్రెడ్‌లను సమకాలీకరించడానికి దాని కొన్ని ప్రధాన విధులను ఉపయోగించేటప్పుడు C లోని POSIX సెమాఫోర్స్ గురించి అంతే. ఈ కథనాన్ని చదివిన తర్వాత, మీరు POSIXని మరింత ఎక్కువగా అర్థం చేసుకోగలరు.