జావాలో సెమాఫోర్ మరియు దాని ఉపయోగం ఏమిటి?

ఒక సెమాఫోర్ ఇన్ కౌంటర్ ద్వారా భాగస్వామ్య వనరుకి ప్రాప్యతను నియంత్రిస్తుంది. ఇది ఒక థ్రెడ్ సమకాలీకరణ తప్పిన సంకేతాలను నివారించడానికి లేదా క్లిష్టమైన విభాగాన్ని కాపాడటానికి థ్రెడ్ల మధ్య సంకేతాలను పంపడానికి ఉపయోగించే నిర్మాణం. జావాలోని సెమాఫోర్స్‌లోని ఈ బ్లాగులో, మేము భావనను వివరంగా అర్థం చేసుకుంటాము.
ఈ బ్లాగులో ఈ క్రింది విషయాలు కవర్ చేయబడతాయి:

• జావాలో సెమాఫోర్స్ అంటే ఏమిటి?
• సెమాఫోర్స్ రకాలు
• సెమాఫోర్ పని
• సెమాఫోర్ అమలు

జావాలో సెమాఫోర్ అంటే ఏమిటి?

సెమాఫోర్ అనేది ప్రక్రియల సమకాలీకరణ కోసం ఉపయోగించే వేరియబుల్, ఇది ఏకకాలిక ప్రక్రియల నిర్వహణకు ఉపయోగించబడుతుంది. బహుళ ఉమ్మడి ప్రక్రియల ద్వారా సాధారణ వనరుకి ప్రాప్యతను నియంత్రించడానికి మరియు జాతి పరిస్థితిని నివారించడానికి కూడా ఇది ఉపయోగించబడుతుంది.

పట్టిక పబ్లిక్ ఎలా ఉపయోగించాలి

సెమాఫోర్ రకాలు -

• బైనరీ సెమాఫోర్: బైనరీ సెమాఫోర్ 0 మరియు 1 మాత్రమే విలువలుగా తీసుకుంటుంది మరియు పరస్పర మినహాయింపును అమలు చేయడానికి మరియు ఏకకాలిక ప్రక్రియలను సమకాలీకరించడానికి ఉపయోగిస్తారు.

• సెమాఫోర్ లెక్కింపు: ఏ సమయంలోనైనా లెక్కింపు సెమాఫోర్ యొక్క విలువ ఖచ్చితమైన సమయంలో క్లిష్టమైన విభాగంలోకి ప్రవేశించగల గరిష్ట ప్రక్రియల సంఖ్యను సూచిస్తుంది.

  
  
  

సెమాఫోర్ పని

• సెమాఫోర్ కౌంట్> 0 అయితే, థ్రెడ్ పర్మిట్‌ను పొందుతుంది, సెమాఫోర్ గణనను తగ్గిస్తుంది.

• లేకపోతే, ది అనుమతి పొందే వరకు నిరోధించబడుతుంది.

• థ్రెడ్‌కు ఇకపై భాగస్వామ్య వనరుకి ప్రాప్యత అవసరం లేనప్పుడు, ఇది పర్మాట్‌ను విడుదల చేస్తుంది, సెమాఫోర్ గణనను పెంచుతుంది.

  
  
  

• మరొక థ్రెడ్ పర్మిట్ కోసం వేచి ఉంటే, ఆ థ్రెడ్ ఆ సమయంలో పర్మిట్ పొందుతుంది.

సెమాఫోర్ అమలు

java.util.concurrent ను దిగుమతి చేసుకోండి. sem = sem this.threadName = threadName public public పబ్లిక్ శూన్య పరుగును ఓవర్రైడ్ చేయండి () {// X ద్వారా రన్ చేస్తే (this.getName (). సమానం ('X')) {System.out.println ('ప్రారంభిస్తోంది' + థ్రెడ్‌నేమ్) ప్రయత్నించండి {// భాగస్వామ్య వనరును యాక్సెస్ చేయడానికి అనుమతి లభిస్తుంది System.out.println (threadName + 'అనుమతి కోసం వేచి ఉంది.') // లాక్ సెమ్.అక్వైర్ () System.out.println (థ్రెడ్‌నేమ్ + 'ను పొందడం పర్మిట్ పొందుతుంది . ') // ఇప్పుడు, భాగస్వామ్య వనరును యాక్సెస్ చేయడం మరియు మిగిలినవి (int i = 0 i<7 i++) { Resource.count++ System.out.println(threadName + ': ' + Resouce.count) // Now thread Y will try to execute Thread.sleep(20) } } catch (InterruptedException exc) { System.out.println(exc) } // Release the permit. System.out.println(threadName + ' releases the permit.') sem.release() } // run by thread Y else { System.out.println('Starting ' + threadName) try { // First, Y will try to get permit System.out.println(threadName + ' waiting for a permit.') // acquiring the lock sem.acquire() System.out.println(threadName + ' gets a permit.') // Now, accessing the shared resource and others will wait for(int i=0 i < 7 i++) { Resource.count-- System.out.println(threadName + ': ' + Resource.count) // Now, allowing a context switch -- if possible. // for thread X to execute Thread.sleep(20) } } catch (InterruptedException exc) { System.out.println(exc) } // Release the permit. System.out.println(threadName + ' releases the permit.') sem.release() } } } public class SemTest { public static void main(String args[]) throws InterruptedException { // creating a Semaphore object // with number of permits 1 Semaphore sem = new Semaphore(1) // creating two threads with name X and Y // Here thread X will increment and Y will decrement the counter MyDemo md1 = new MyDemo(sem, 'X') MyDemo md2 = new MyDemo(sem, 'Y') // stating threads X and Y md1.start() md2.start() // waiting for threads X and Y md1.join() mtd.join() System.out.println('count: ' + Resource.count) } } 

అవుట్పుట్-
X ప్రారంభిస్తోంది
Y ను ప్రారంభిస్తోంది
X పర్మిట్ కోసం వేచి ఉంది
Y పర్మిట్ కోసం వేచి ఉంది
X: 1
X: 2
X: 3
X: 4
X: 5
X: 6
X: 7
X అనుమతిని విడుదల చేస్తుంది
Y కి పర్మిట్ వస్తుంది
వై: 6
వై: 5
వై: 4
వై: 3
వై: 2
వై: 1
వై: 0
మరియు విడుదలల అనుమతి
లెక్కింపు: 0

దీనితో, “జావాలోని సెమాఫోర్స్” లో ఈ బ్లాగ్ ముగింపుకు వచ్చాము. మీరు జావా గురించి మరింత తెలుసుకోవాలనుకుంటే, చూడండి ప్రపంచవ్యాప్తంగా విస్తరించి ఉన్న 250,000 మందికి పైగా సంతృప్తికరమైన అభ్యాసకుల నెట్‌వర్క్‌తో విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత. ఎడురేకా యొక్క జావా J2EE మరియు SOA శిక్షణ మరియు ధృవీకరణ కోర్సు జావా డెవలపర్‌గా ఉండాలనుకునే విద్యార్థులు మరియు నిపుణుల కోసం రూపొందించబడింది. ఈ కోర్సు మీకు జావా ప్రోగ్రామింగ్‌లోకి రావడానికి మరియు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌లతో పాటు కోర్ మరియు అడ్వాన్స్‌డ్ జావా కాన్సెప్ట్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడింది.

మాకు ప్రశ్న ఉందా? దయచేసి ఈ “జావాలో సెమాఫోర్ అంటే ఏమిటి” బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.