మ్యూటెక్స్, మానిటర్ మరియు సెమాఫోర్ మధ్య వ్యత్యాసం

హాయ్! మీరు కోడ్‌జిమ్‌లో మల్టీథ్రెడింగ్‌ని అధ్యయనం చేసినప్పుడు, మీరు తరచుగా "మ్యూటెక్స్" మరియు "మానిటర్" భావనలను ఎదుర్కొన్నారు. చూడకుండా, అవి ఎలా విభేదిస్తాయో చెప్పగలరా? :) అవును అయితే, బాగా చేసారు! కాకపోతే (ఇది సర్వసాధారణం), అందులో ఆశ్చర్యం లేదు. "మ్యూటెక్స్" మరియు "మానిటర్" వాస్తవానికి సంబంధిత భావనలు. అదనంగా, మీరు ఇతర వెబ్‌సైట్‌లలో మల్టీథ్రెడింగ్ గురించి పాఠాలను చదివినప్పుడు మరియు వీడియోలను చూసినప్పుడు, మీరు మరొక సారూప్య భావనను చూస్తారు: "సెమాఫోర్". ఇది మానిటర్లు మరియు మ్యూటెక్స్‌లకు చాలా సారూప్యమైన ఫంక్షన్‌ను కూడా కలిగి ఉంది. అందుకే ఈ మూడు పదాలను పరిశోధించబోతున్నాం. మేము కొన్ని ఉదాహరణలను పరిశీలిస్తాము మరియు ఈ భావనలు ఒకదానికొకటి ఎలా భిన్నంగా ఉంటాయి అనేదానిపై ఖచ్చితమైన అవగాహనకు వస్తాము :)

మ్యూటెక్స్

మ్యూటెక్స్ (లేదా లాక్) అనేది థ్రెడ్‌లను సమకాలీకరించడానికి ఒక ప్రత్యేక విధానం. జావాలోని ప్రతి వస్తువుకు ఒకటి "అటాచ్ చేయబడింది" — ఇది మీకు ఇప్పటికే తెలుసు :) మీరు ప్రామాణిక తరగతులను ఉపయోగించినా లేదా మీ స్వంత తరగతులను సృష్టించినా పర్వాలేదు, ఉదా క్యాట్ మరియు డాగ్ : అన్ని తరగతుల వస్తువులు మ్యూటెక్స్‌ను కలిగి ఉంటాయి . "మ్యూటెక్స్" అనే పదం "మ్యూచువల్ ఎక్స్‌క్లూజన్" నుండి వచ్చింది, ఇది దాని ప్రయోజనాన్ని ఖచ్చితంగా వివరిస్తుంది. మేము మా మునుపటి పాఠాలలో ఒకదానిలో చెప్పినట్లుగా, మ్యూటెక్స్ ఒక సమయంలో ఒక థ్రెడ్ మాత్రమే ఆబ్జెక్ట్‌కు యాక్సెస్‌ని కలిగి ఉండేలా చేస్తుంది. మ్యూటెక్స్ యొక్క ప్రసిద్ధ నిజ జీవిత ఉదాహరణ మరుగుదొడ్లను కలిగి ఉంటుంది. ఒక వ్యక్తి టాయిలెట్ విభజనలోకి ప్రవేశించినప్పుడు, అతను లోపలి నుండి తలుపును లాక్ చేస్తాడు. టాయిలెట్ అనేది బహుళ థ్రెడ్‌ల ద్వారా యాక్సెస్ చేయగల వస్తువు లాంటిది. విభజన తలుపుపై ​​తాళం మ్యూటెక్స్ లాగా ఉంటుంది మరియు బయట ఉన్న వ్యక్తుల లైన్ థ్రెడ్‌లను సూచిస్తుంది. తలుపుకు ఉన్న తాళం టాయిలెట్ యొక్క మ్యూటెక్స్: ఇది కేవలం ఒక వ్యక్తి మాత్రమే లోపలికి వెళ్లగలదని నిర్ధారిస్తుంది. మరో మాటలో చెప్పాలంటే, ఒకే సమయంలో ఒక థ్రెడ్ మాత్రమే భాగస్వామ్య వనరులతో పని చేయగలదు. ఇతర థ్రెడ్‌లు (వ్యక్తులు) ఆక్రమిత వనరులను యాక్సెస్ చేయడానికి చేసే ప్రయత్నాలు విఫలమవుతాయి. మ్యూటెక్స్ అనేక ముఖ్యమైన లక్షణాలను కలిగి ఉంది. మొదటిది , రెండు రాష్ట్రాలు మాత్రమే సాధ్యమవుతాయి: "అన్‌లాక్ చేయబడింది" మరియు "లాక్ చేయబడింది". ఇది ఎలా పని చేస్తుందో అర్థం చేసుకోవడానికి ఇది మాకు సహాయపడుతుంది: మీరు బూలియన్ వేరియబుల్స్ (నిజం/తప్పు) లేదా బైనరీ సంఖ్యలతో (0/1) సమాంతరాలను గీయవచ్చు. , రాష్ట్రాన్ని నేరుగా నియంత్రించలేము. జావాలో ఒక వస్తువును స్పష్టంగా తీసుకోవడానికి, దాని మ్యూటెక్స్‌ని పొందడానికి మరియు కావలసిన స్థితిని కేటాయించడానికి మిమ్మల్ని అనుమతించే యంత్రాంగం లేదు. మరో మాటలో చెప్పాలంటే, మీరు ఇలాంటివి చేయలేరు:

Object myObject = new Object();
Mutex mutex = myObject.getMutex();
mutex.free();

మీరు ఆబ్జెక్ట్ యొక్క మ్యూటెక్స్‌ని విడుదల చేయలేరని దీని అర్థం. కేవలం జావా మెషీన్‌కు మాత్రమే నేరుగా యాక్సెస్ ఉంటుంది. ప్రోగ్రామర్లు భాష యొక్క సాధనాల ద్వారా మ్యూటెక్స్‌లతో పని చేస్తారు.

మానిటర్

మానిటర్ అనేది మ్యూటెక్స్‌పై అదనపు "సూపర్ స్ట్రక్చర్". వాస్తవానికి, మానిటర్ అనేది ప్రోగ్రామర్‌కు "అదృశ్యం" అయిన కోడ్ యొక్క భాగం. మేము ఇంతకు ముందు మ్యూటెక్స్ గురించి మాట్లాడినప్పుడు, మేము ఒక సాధారణ ఉదాహరణ ఇచ్చాము:

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...some logic, available for all threads

       synchronized (obj) {

           // Logic available to just one thread at a time
       }
   }
}

సమకాలీకరించబడిన కీవర్డ్‌తో గుర్తించబడిన కోడ్ బ్లాక్‌లో , మన obj వస్తువు యొక్క మ్యూటెక్స్ పొందబడుతుంది. గ్రేట్, మేము లాక్‌ని పొందగలము, అయితే "రక్షణ" సరిగ్గా ఎలా అందించబడుతుంది? మేము సమకాలీకరించబడిన పదాన్ని చూసినప్పుడు , ఇతర థ్రెడ్‌లు బ్లాక్‌లోకి ప్రవేశించకుండా ఏది నిరోధిస్తుంది? రక్షణ మానిటర్ నుండి వస్తుంది! కంపైలర్ సమకాలీకరించబడిన కీవర్డ్‌ని అనేక ప్రత్యేక కోడ్ ముక్కలుగా మారుస్తుంది. మరోసారి, doSomething() పద్ధతితో మన ఉదాహరణకి తిరిగి వెళ్దాం. మేము దానికి జోడిస్తాము:

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...some logic, available for all threads

       // Logic available to just one thread at a time
       synchronized (obj) {

           /* Do important work that requires that the object
           be accessed by only one thread */
           obj.someImportantMethod();
       }
   }
}

కంపైలర్ ఈ కోడ్‌ను మార్చిన తర్వాత "అండర్ ది హుడ్" ఏమి జరుగుతుందో ఇక్కడ ఉంది:

public class Main {

   private Object obj = new Object();

   public void doSomething() throws InterruptedException {

       // ...some logic, available for all threads

       // Logic available to just one thread at a time:
     
       /* as long as the object's mutex is busy,
       all the other threads (except the one that acquired it) are put to sleep */
       while (obj.getMutex().isBusy()) {
           Thread.sleep(1);
       }

       // Mark the object's mutex as busy
       obj.getMutex().isBusy() = true;

       /* Do important work that requires that the object
       be accessed by only one thread */
       obj.someImportantMethod();

       // Free the object's mutex
       obj.getMutex().isBusy() = false;
   }
}

వాస్తవానికి, ఇది నిజమైన ఉదాహరణ కాదు. ఇక్కడ, జావా మెషీన్ లోపల ఏమి జరుగుతుందో వివరించడానికి మేము జావా లాంటి కోడ్‌ని ఉపయోగించాము. సమకాలీకరించబడిన బ్లాక్‌లోని వస్తువు మరియు థ్రెడ్‌లతో వాస్తవంగా ఏమి జరుగుతుందో మరియు కంపైలర్ ఈ కీవర్డ్‌ను ప్రోగ్రామర్‌కు "అదృశ్యం"గా ఉండే అనేక స్టేట్‌మెంట్‌లుగా ఎలా మారుస్తుందనే దాని గురించి ఈ నకిలీ-కోడ్ అద్భుతమైన అవగాహనను ఇస్తుంది. ప్రాథమికంగా, మానిటర్‌ను సూచించడానికి జావా సమకాలీకరించబడిన కీవర్డ్‌ని ఉపయోగిస్తుంది . చివరి ఉదాహరణలో సమకాలీకరించబడిన కీవర్డ్‌కు బదులుగా కనిపించే అన్ని కోడ్ మానిటర్.

సెమాఫోర్

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

Semaphore(int permits)
Semaphore(int permits, boolean fair)

మేము ఈ క్రింది వాటిని కన్స్ట్రక్టర్‌కు పంపుతాము:

int అనుమతులు - కౌంటర్ యొక్క ప్రారంభ మరియు గరిష్ట విలువ. మరో మాటలో చెప్పాలంటే, భాగస్వామ్య వనరును ఏకకాలంలో ఎన్ని థ్రెడ్‌లు యాక్సెస్ చేయవచ్చో ఈ పరామితి నిర్ణయిస్తుంది;
• బూలియన్ ఫెయిర్ — థ్రెడ్‌లు యాక్సెస్ పొందే క్రమాన్ని ఏర్పాటు చేస్తుంది. సరైనది అయితే, వారు అభ్యర్థించిన క్రమంలో వేచి ఉండే థ్రెడ్‌లకు యాక్సెస్ మంజూరు చేయబడుతుంది. అది తప్పు అయితే, ఆర్డర్ థ్రెడ్ షెడ్యూలర్ ద్వారా నిర్ణయించబడుతుంది.

సెమాఫోర్ ఉపయోగం యొక్క ఒక క్లాసిక్ ఉదాహరణ డైనింగ్ ఫిలాసఫర్ సమస్య. అవగాహనను సులభతరం చేయడానికి, మేము దానిని కొద్దిగా సరళీకృతం చేస్తాము. మనకు మధ్యాహ్న భోజనం చేయాల్సిన ఐదుగురు తత్వవేత్తలు ఉన్నారని ఊహించండి. అదనంగా, మాకు ఒక టేబుల్ ఉంది, అది ఒకేసారి ఇద్దరు వ్యక్తుల కంటే ఎక్కువ ఉండకూడదు. తత్త్వవేత్తలందరికీ ఆహారం అందించడమే మన పని. వారిలో ఎవరూ ఆకలితో ఉండకూడదు మరియు టేబుల్ వద్ద కూర్చోవడానికి ప్రయత్నిస్తున్నప్పుడు వారిలో ఎవరూ ఒకరినొకరు "నిరోధించకూడదు" (మనం ప్రతిష్టంభనను నివారించాలి). మా ఫిలాసఫర్ క్లాస్ ఎలా ఉంటుందో ఇక్కడ ఉంది:

class Philosopher extends Thread {

   private Semaphore sem;

   // Did the philosopher eat?
   private boolean full = false;

   private String name;

   Philosopher(Semaphore sem, String name) {
       this.sem=sem;
       this.name=name;
   }

   public void run()
   {
       try
       {
           // If the philosopher has not eaten
           if (!full) {
               // Ask the semaphore for permission to run
               sem.acquire();
               System.out.println(name + " takes a seat at the table");

               // The philosopher eats
               sleep(300);
               full = true;

               System.out.println(name + " has eaten! He leaves the table");
               sem.release();

               // The philosopher leaves, making room for others
               sleep(300);
           }
       }
       catch(InterruptedException e) {
           System.out.println("Something went wrong!");
       }
   }
}

మరియు మా ప్రోగ్రామ్‌ను అమలు చేయడానికి ఇక్కడ కోడ్ ఉంది:

public class Main {

   public static void main(String[] args) {

       Semaphore sem = new Semaphore(2);
       new Philosopher(sem, "Socrates").start();
       new Philosopher(sem,"Plato").start();
       new Philosopher(sem,"Aristotle").start();
       new Philosopher(sem, "Thales").start();
       new Philosopher(sem, "Pythagoras").start();
   }
}

మేము ఒక సెమాఫోర్‌ను సృష్టించాము, దీని కౌంటర్ 2కి సెట్ చేయబడింది, ఇది షరతును సంతృప్తిపరుస్తుంది: ఇద్దరు తత్వవేత్తలు మాత్రమే ఒకే సమయంలో తినగలరు. అంటే, ఒకే సమయంలో రెండు థ్రెడ్‌లు మాత్రమే అమలు చేయగలవు, ఎందుకంటే మన ఫిలాసఫర్ క్లాస్ థ్రెడ్‌ని వారసత్వంగా పొందుతుంది ! సెమాఫోర్ క్లాస్ యొక్క అక్వైర్ () మరియు రిలీజ్() పద్ధతులు దాని యాక్సెస్ కౌంటర్‌ని నియంత్రిస్తాయి. సముపార్జన () పద్ధతి వనరుకు ప్రాప్యత కోసం సెమాఫోర్‌ను అడుగుతుంది. కౌంటర్ >0 అయితే, యాక్సెస్ మంజూరు చేయబడుతుంది మరియు కౌంటర్ 1 ద్వారా తగ్గించబడుతుంది. విడుదల ()పద్ధతి గతంలో మంజూరు చేయబడిన యాక్సెస్‌ను "విడుదల చేస్తుంది", దానిని కౌంటర్‌కి తిరిగి ఇస్తుంది (సెమాఫోర్ యాక్సెస్ కౌంటర్‌ను 1 ద్వారా పెంచుతుంది). మేము ప్రోగ్రామ్‌ను అమలు చేసినప్పుడు మనకు ఏమి లభిస్తుంది? సమస్య పరిష్కారమైందా? మన తత్వవేత్తలు తమ వంతు కోసం ఎదురుచూస్తూ పోరాడకుండా ఉంటారా? :) మనకు లభించిన కన్సోల్ అవుట్‌పుట్ ఇక్కడ ఉంది:

Socrates takes a seat at the table 
Plato takes a seat at the table 
Socrates has eaten! He leaves the table 
Plato has eaten! He leaves the table 
Aristotle takes a seat at the table 
Pythagoras takes a seat at the table 
Aristotle has eaten! He leaves the table 
Pythagoras has eaten! He leaves the table 
Thales takes a seat at the table 
Thales has eaten! He leaves the table 

మేము చేసాము! మరియు థేల్స్ ఒంటరిగా భోజనం చేయవలసి వచ్చినప్పటికీ, మేము అతనిని బాధపెట్టామని నేను అనుకోను :) మ్యూటెక్స్ మరియు సెమాఫోర్ మధ్య కొన్ని సారూప్యతలను మీరు గమనించి ఉండవచ్చు. నిజానికి, వారికి ఒకే లక్ష్యం ఉంది: కొన్ని వనరులకు ప్రాప్యతను సమకాలీకరించడం. ఒకే తేడా ఏమిటంటే, ఒక వస్తువు యొక్క మ్యూటెక్స్‌ను ఒకేసారి ఒక థ్రెడ్ ద్వారా మాత్రమే పొందవచ్చు, అయితే థ్రెడ్ కౌంటర్‌ను ఉపయోగించే సెమాఫోర్ విషయంలో, అనేక థ్రెడ్‌లు ఏకకాలంలో వనరును యాక్సెస్ చేయగలవు. ఇది కేవలం యాదృచ్చికం కాదు :) మ్యూటెక్స్ నిజానికి సెమాఫోర్1 యొక్క గణనతో. మరో మాటలో చెప్పాలంటే, ఇది ఒకే థ్రెడ్‌కు అనుగుణంగా ఉండే సెమాఫోర్. దీనిని "బైనరీ సెమాఫోర్" అని కూడా పిలుస్తారు, ఎందుకంటే దాని కౌంటర్ కేవలం 2 విలువలను కలిగి ఉంటుంది — 1 ("అన్‌లాక్ చేయబడింది") మరియు 0 ("లాక్ చేయబడింది"). అంతే! మీరు చూడగలిగినట్లుగా, ఇది చాలా గందరగోళంగా లేదు :) ఇప్పుడు, మీరు ఇంటర్నెట్‌లో మల్టీథ్రెడింగ్‌ను మరింత వివరంగా అధ్యయనం చేయాలనుకుంటే, ఈ భావనలను నావిగేట్ చేయడం మీకు కొంచెం సులభం అవుతుంది. తదుపరి పాఠాలలో కలుద్దాం!