POSIX అనేది OS యొక్క పోర్టబుల్ ఇంటర్‌ఫేస్‌ని సూచిస్తుంది, ఇది IEEE ప్రమాణం, వివిధ అప్లికేషన్ల పోర్టబిలిటీకి సహాయపడటానికి అభివృద్ధి చేయబడింది. POSIX అనేది విక్రేతల సహకారం ద్వారా UNIX యొక్క సాధారణ ప్రామాణిక వెర్షన్‌ను రూపొందించే ప్రయత్నం. ఇది హార్డ్‌వేర్ ప్లాట్‌ఫారమ్‌ల మధ్య పోర్ట్‌లను ప్రభావవంతంగా ఉన్నట్లయితే సులభంగా పోర్ట్‌ చేస్తుంది. హ్యూలెట్-ప్యాకార్డ్ POSIX ని దాని లైసెన్స్ పొందిన MPE/iX OS వెర్షన్ 5.0 మరియు HP/UXX వెర్షన్ 10.0 లలో వరుసగా కలుపుతోంది (దాని UNIX).
POSIX ప్రమాణం పది కంటే ఎక్కువ భాగాలను కలిగి ఉంది, అయితే, రెండు సులభంగా పొందవచ్చు. POSIX.1 ఫైల్‌లు, ప్రక్రియలు మరియు I/O టెర్మినల్స్ కోసం C ప్రోగ్రామింగ్ ఇంటర్‌ఫేస్‌లను (అంటే, సిస్టమ్ కాల్ లైబ్రరీ) వివరిస్తుంది. POSIX ప్లాట్‌ఫారమ్‌ల కోసం C POSIX ప్యాకేజీ లైబ్రరీ అనేది C స్టాండర్డ్ లైబ్రరీ యొక్క ఫ్రేమ్‌వర్క్. ప్రామాణిక ANSI C. అదే సమయంలో ఇది స్థాపించబడింది, POSIX ను ప్రామాణిక C కి అనుగుణంగా చేయడానికి, అనేక ప్రయత్నాలు జరిగాయి. POSIX స్టాండర్డ్ C లో అమలు చేయబడిన వాటికి అదనపు ఫీచర్లను అందిస్తుంది.
POSIX సెమాఫోర్స్
సెమాఫోర్ అనేది ఒక డేటా స్ట్రక్చర్, ఇది ప్రక్రియలను సమకాలీకరించడానికి మరియు థ్రెడ్లు ఒకదానితో ఒకటి పరస్పర చర్య లేకుండా కలిసి పనిచేయడానికి తరచుగా సహాయపడతాయి. సెమాఫోర్స్ కోసం ఇంటర్ఫేస్ POSIX ప్రమాణం ద్వారా పేర్కొనబడింది. ఇది Pthreads లో భాగం కాదు. అయితే, Pthreads కి మద్దతిచ్చే చాలా UNIX లు సెమాఫోర్‌లను కూడా అందిస్తాయి. లైనక్స్ వంటి యునిక్స్ లాంటి ఫ్రేమ్‌వర్క్‌లలో, ఇంటర్‌ప్రోసెస్ కమ్యూనికేషన్ (IPC) సర్వీసుల క్రింద సెమఫోర్స్ మెసేజ్ క్యూలు మరియు కామన్ మెమరీతో విలీనం చేయబడతాయి. పాత ఫ్రేమ్‌వర్క్ V సెమాఫోర్స్ మరియు ఆధునిక POSIX సెమాఫోర్స్ రెండు రకాల సెమాఫోర్స్‌గా మారాయి. సిస్టమ్ V సెమాఫోర్ కాల్‌ల కంటే POSIX సెమాఫోర్ కాలింగ్ చాలా సులభం. అయినప్పటికీ, సిస్టమ్ V సెమాఫోర్స్ పొందడం సులభం, ముఖ్యంగా మునుపటి యునిక్స్ లాంటి ప్లాట్‌ఫారమ్‌లలో. POSIX సెమాఫోర్స్ ఉపయోగించి ప్రోగ్రామ్‌లను Pthread లైబ్రరీకి కనెక్ట్ చేయడం అవసరం. మేము ఈ వ్యాసంలోని POSIX సెమాఫోర్‌లను పరిశీలిస్తాము.
ఎందుకు POSIX సెమాఫోర్స్?
జాతుల పరిస్థితి అయిన థ్రెడ్‌ల చుట్టూ పెద్ద సమస్య ఉంది. ఇది రెండు థ్రెడ్లు ఒకే సమాచారాన్ని పొందడానికి మరియు మార్చడానికి ప్రయత్నించే పరిస్థితి, తద్వారా అది విరుద్ధంగా ఉంటుంది. జాతి పరిస్థితిని నివారించడానికి, మేము చాలా కాలంగా సెమాఫోర్‌లను ఉపయోగిస్తున్నాము.
సెమాఫోర్స్ 2 రకాలుగా లభిస్తాయి:
బైనరీ సెమాఫోర్ :
ఇది మ్యూటెక్స్ లాక్‌గా కూడా గుర్తించబడింది. ఇది 0 మరియు 1. అనే రెండు విలువలను మాత్రమే కలిగి ఉంటుంది. విలువ 1 గా ప్రారంభించబడుతుంది. తీవ్రమైన విభాగం సమస్యను పరిష్కరించడానికి అనేక ప్రక్రియలను అమలు చేయడానికి ఇది ఉపయోగించబడుతుంది.
సెమాఫోర్ లెక్కింపు :
దీని పరిమాణం అనియంత్రిత డొమైన్‌లో మారవచ్చు. అనేక-ఉదాహరణ వనరులకు ప్రాప్యతపై అధికారం కలిగి ఉండటానికి ఇది ఉపయోగించబడుతోంది.
Linux POSIX ఫ్రేమ్‌వర్క్ దాని ఇంటిగ్రేటెడ్ సెమాఫోర్ రిపోజిటరీని కలిగి ఉంది. దీన్ని ఉపయోగించడానికి, మేము తప్పక:
- Semaphore.h ని జోడించండి
- -Lpthread -lrt తో కనెక్ట్ చేయడం ద్వారా కోడ్‌ను పోగు చేయండి.
దాదాపు అన్ని POSIX సెమాఫోర్ పద్ధతులు మరియు రూపాలు 'Semaphore.h' లో ప్రోటోటైప్ చేయబడ్డాయి లేదా పేర్కొనబడ్డాయి. మేము ఒక ఎంటిటీ లేదా వస్తువును వివరించడానికి సెమాఫోర్‌ని ఉపయోగిస్తాము:
>>sem_t sem_name;POSIX సెమాఫోర్‌లో మేము ఉపయోగించే విభిన్న విధులు ఇక్కడ ఉన్నాయి.
Sem_init
సెమాఫోర్‌ను ప్రారంభించడానికి, మీరు sem_init పద్ధతిని ఉపయోగించాలి. ఈ ఫంక్షన్‌లో, సెమ్ ప్రారంభించిన సెమాఫోర్ ఆబ్జెక్ట్‌కు అనుగుణంగా ఉంటుంది. షేర్డ్ అనేది బ్యానర్ లేదా జెండా, ఇది సెమాఫోర్‌ను ఫోర్క్డ్ () ప్రొసీజర్‌తో షేర్ చేయవచ్చో లేదో తెలుపుతుంది. షేర్డ్ సెమాఫోర్స్ ప్రస్తుతం LinuxThreads ద్వారా బ్రేస్ చేయబడలేదు. వాదన విలువ అనేది సెమాఫోర్ స్థిరంగా ఉండే ప్రారంభ విలువ.
>> intsem_init(sem_t*sem, intషేర్ చేయబడింది, సంతకం చేయలేదు intవిలువ);Sem_ వేచి ఉండండి
మేము సెమాఫోర్‌ను పట్టుకోవడానికి/లాక్ చేయడానికి లేదా వేచి ఉండేలా చేయడానికి సెమ్-వెయిట్ పద్ధతిని ఉపయోగిస్తాము. సెమాఫోర్‌కు ప్రతికూల విలువ అందించబడితే, కాల్ సైకిల్ ఆటోమేటిక్‌గా బ్లాక్ చేయబడుతుంది. ఏదైనా ఇతర థ్రెడ్ sem_post కి కాల్ చేసినప్పుడు, ఇప్పటికే అడ్డుపడే ప్రక్రియలలో ఒకటి మేల్కొంటుంది.
>> intsem_ వేచి ఉండండి(sem_t*sem);Sem_post
సెమాఫోర్ విలువను పెంచడానికి మేము sem_post పద్ధతిని ఉపయోగిస్తాము. కాల్ చేసిన తర్వాత, sem_post విలువను పెంచుతుంది మరియు ఇప్పటికే అడ్డుపడే లేదా వేచి ఉండే ప్రక్రియలలో ఒకటి మేల్కొంటుంది.
>> intsem_post(sem_t*sem);Sem_getvalue
మీరు సెమాఫోర్ విలువ గురించి తెలుసుకోవాలనుకుంటే, మీరు దిగువ sem_getvalue ఫంక్షన్‌ను ఉపయోగించాలి. ఇది సెమాఫోర్ యొక్క ప్రస్తుత విలువను పొందుతుంది మరియు వాల్ప్-పాయింటెడ్ గమ్యస్థానంలో ఉంచబడుతుంది.
>>Int sem_getvalue(sem_t*sem, int *కుక్కపిల్ల);Sem_destroy
మీరు సెమాఫోర్‌ను నాశనం చేయాలనుకుంటే మీరు sem_destroy పద్ధతిని ఉపయోగించాలి. సెమాఫోర్ యొక్క మరణం కొనసాగాలంటే, సెమాఫోర్‌లో ఎలాంటి థ్రెడ్ వేచి ఉండదు.
>>Int sem_destroy(sem_t*sem);GCC యుటిలిటీని ఇన్‌స్టాల్ చేయండి
POSIX సెమాఫోర్ C కోడ్‌ను కంపైల్ చేయడానికి, మీరు మీ Linux సిస్టమ్‌లో gcc యుటిలిటీని ఇన్‌స్టాల్ చేసి ఉండాలి. ఈ ప్రయోజనం కోసం, మీ కమాండ్ టెర్మినల్‌ను తెరిచి, కింది ఆదేశాన్ని ప్రయత్నించండి.
$సుడో apt-get install gcc 
నొక్కడం ద్వారా మీ చర్యను నిర్ధారించండి మరియు .
ఉబుంటులో సి ప్రోగ్రామింగ్‌తో POSIX సెమాఫోర్ అమలు
ప్రారంభంలోనే, మీరు ఉబుంటు 20.04 సిస్టమ్‌లో .cpp ఎక్స్‌టెన్షన్‌తో కొత్త ఫైల్‌ను సృష్టించాలి. దీని కోసం, మీరు మీ హోమ్ డైరెక్టరీ వైపు నావిగేట్ చేయాలి మరియు new.cpp అనే కొత్త ఖాళీ ఫైల్‌ను సృష్టించాలి. మీరు మీ కమాండ్ టెర్మినల్‌లోని టచ్ కమాండ్ ఉపయోగించి కూడా దీన్ని సృష్టించవచ్చు.
హోమ్ డైరెక్టరీలో new.cpp ఫైల్ సృష్టించబడిందని మీరు చూడవచ్చు.
.Cpp ఫైల్ సృష్టించిన తర్వాత, దాన్ని మీ Linux సిస్టమ్‌లో టెక్స్ట్ ఎడిటర్‌గా తెరిచి, కింది ఫైల్‌ను ఈ ఫైల్‌లో అలాగే రాయండి. ఆ తరువాత, దాన్ని సేవ్ చేసి మూసివేయండి.
ఉబుంటు 20.04 లో POSIX సెమాఫోర్ C ప్రోగ్రామ్‌ను అమలు చేయండి
ఉబుంటు 20.04 లో మీ టెర్మినల్‌ని తెరిచి, కింది gcc ఆదేశాన్ని అమలు చేయండి మరియు ఫైల్ పేరును అనుసరించండి.
$gccfilename.c –lpthread –lrt 
2 థ్రెడ్లు ఏర్పడ్డాయి, ఒకటి 2 సెకన్ల తర్వాత ఏర్పడుతుంది. బోల్ట్ అందుకున్న తర్వాత, మొదటి థ్రెడ్ 4 సెకన్ల పాటు నిద్రపోతుంది. కాబట్టి, దీనిని పిలిచిన తర్వాత, రెండవ థ్రెడ్ నేరుగా చేరదు, మరియు ఇది పిలవబడిన 4-2 = 2 సెకన్ల తర్వాత కనిపిస్తుంది. అవుట్‌పుట్ ఇక్కడ ఉంది:
సందర్భ మార్పిడి ప్రకారం, మేము సెమాఫోర్‌ను ఉపయోగించకపోతే, ఫలితం గమనించినట్లుగా ఉండవచ్చు:
ముగింపు
ఈ గైడ్‌లో, ఉబుంటు 20 లో సి ప్రోగ్రామింగ్‌తో POSIXSemaphore ఉపయోగం గురించి వివరణాత్మక అవలోకనం ఇవ్వబడింది. నిర్దిష్ట C కోడ్ అంతటా కేవలం POSIX లేదా Pthread లైబ్రరీని ఉపయోగించడం ద్వారా, POSIX Semaphore ను కోడింగ్ సమయంలో జాతి పరిస్థితులను నివారించడానికి చాలా సులభంగా ఉపయోగించవచ్చు.