ஒரு மியூடெக்ஸ், ஒரு மானிட்டர் மற்றும் ஒரு செமாஃபோர் இடையே உள்ள வேறுபாடு

வணக்கம்! நீங்கள் கோட்ஜிம்மில் மல்டித்ரெடிங்கைப் படித்தபோது, ​​"மியூடெக்ஸ்" மற்றும் "மானிட்டர்" ஆகிய கருத்துகளை அடிக்கடி சந்தித்தீர்கள். எட்டிப்பார்க்காமல், அவை எப்படி வேறுபடுகின்றன என்று சொல்ல முடியுமா? :) ஆம் எனில், நன்றாக முடிந்தது! இல்லையென்றால் (இது மிகவும் பொதுவானது), அதில் ஆச்சரியமில்லை. "Mutex" மற்றும் "monitor" ஆகியவை உண்மையில் தொடர்புடைய கருத்துக்கள். கூடுதலாக, நீங்கள் பாடங்களைப் படிக்கும்போது மற்றும் பிற வலைத்தளங்களில் மல்டித்ரெடிங் பற்றிய வீடியோக்களைப் பார்க்கும்போது, ​​இதேபோன்ற மற்றொரு கருத்தை நீங்கள் காண்பீர்கள்: "செமாஃபோர்". இது மானிட்டர்கள் மற்றும் மியூடெக்ஸ்களுக்கு மிகவும் ஒத்த செயல்பாட்டைக் கொண்டுள்ளது. அதனால்தான் இந்த மூன்று விதிமுறைகளையும் நாங்கள் விசாரிக்கப் போகிறோம். நாம் ஒரு சில உதாரணங்களைப் பார்த்து, இந்தக் கருத்துக்கள் எப்படி ஒன்றுக்கொன்று வேறுபடுகின்றன என்பதைப் பற்றிய உறுதியான புரிதலுக்கு வருவோம் :)

மியூடெக்ஸ்

ஒரு மியூடெக்ஸ் (அல்லது பூட்டு) என்பது நூல்களை ஒத்திசைப்பதற்கான ஒரு சிறப்பு வழிமுறையாகும். ஒன்று ஜாவாவில் உள்ள ஒவ்வொரு பொருளுடனும் "இணைக்கப்பட்டுள்ளது" — உங்களுக்கு ஏற்கனவே தெரியும் :) நீங்கள் நிலையான வகுப்புகளைப் பயன்படுத்தினாலும் அல்லது உங்கள் சொந்த வகுப்புகளை உருவாக்கினாலும் பரவாயில்லை, எ.கா. பூனை மற்றும் நாய் : அனைத்து வகுப்புகளின் அனைத்துப் பொருட்களும் ஒரு மியூடெக்ஸைக் கொண்டுள்ளன . "Mutex" என்ற சொல் "MUTual EXclusion" என்பதிலிருந்து வந்தது, இது அதன் நோக்கத்தை சரியாக விவரிக்கிறது. எங்கள் முந்தைய பாடங்களில் ஒன்றில் நாங்கள் கூறியது போல், ஒரு நேரத்தில் ஒரு நூல் மட்டுமே பொருளை அணுகுவதை உறுதி செய்வதை மியூடெக்ஸ் சாத்தியமாக்குகிறது. மியூடெக்ஸின் பிரபலமான நிஜ வாழ்க்கை உதாரணம் கழிப்பறைகளை உள்ளடக்கியது. ஒரு நபர் ஒரு கழிப்பறை பகிர்வுக்குள் நுழையும் போது, ​​அவர் கதவை உள்ளே இருந்து பூட்டுகிறார். கழிப்பறை என்பது பல நூல்களால் அணுகக்கூடிய ஒரு பொருளைப் போன்றது. பகிர்வு கதவின் பூட்டு ஒரு மியூடெக்ஸ் போன்றது, மேலும் வெளியில் உள்ளவர்களின் வரிசை நூல்களைக் குறிக்கிறது. கதவின் பூட்டு கழிப்பறையின் மியூடெக்ஸ் ஆகும்: இது ஒரு நபர் மட்டுமே உள்ளே செல்ல முடியும் என்பதை உறுதி செய்கிறது. வேறு வார்த்தைகளில் கூறுவதானால், ஒரு நேரத்தில் ஒரு நூல் மட்டுமே பகிரப்பட்ட ஆதாரங்களுடன் வேலை செய்ய முடியும். ஆக்கிரமிக்கப்பட்ட ஆதாரங்களுக்கான அணுகலைப் பெற மற்ற நூல்களின் (மக்கள்) முயற்சிகள் தோல்வியடையும். ஒரு மியூடெக்ஸ் பல முக்கிய அம்சங்களைக் கொண்டுள்ளது. முதலில் , இரண்டு நிலைகள் மட்டுமே சாத்தியம்: "திறக்கப்பட்டது" மற்றும் "பூட்டப்பட்டது". இது எவ்வாறு செயல்படுகிறது என்பதைப் புரிந்துகொள்ள இது உதவுகிறது: நீங்கள் பூலியன் மாறிகள் (உண்மை/தவறு) அல்லது பைனரி எண்கள் (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 permits — கவுண்டரின் ஆரம்ப மற்றும் அதிகபட்ச மதிப்பு. வேறு வார்த்தைகளில் கூறுவதானால், பகிரப்பட்ட வளத்தை ஒரே நேரத்தில் எத்தனை நூல்கள் அணுகலாம் என்பதை இந்த அளவுரு தீர்மானிக்கிறது;
• boolean fair — நூல்கள் அணுகலைப் பெறும் வரிசையை நிறுவுகிறது. நியாயமானது உண்மையாக இருந்தால், காத்திருப்பு தொடரிழைகளுக்கு அவர்கள் கோரிய வரிசையில் அணுகல் வழங்கப்படும். அது தவறானதாக இருந்தால், வரிசையை த்ரெட் ஷெட்யூலரால் தீர்மானிக்கப்படும்.

செமாஃபோர் பயன்பாட்டிற்கு ஒரு சிறந்த உதாரணம் சாப்பாட்டு தத்துவஞானி பிரச்சனை. புரிந்து கொள்ள வசதியாக, நாம் அதை சிறிது எளிதாக்குவோம். மதிய உணவு சாப்பிட வேண்டிய 5 தத்துவவாதிகள் எங்களிடம் இருப்பதாக கற்பனை செய்து பாருங்கள். கூடுதலாக, எங்களிடம் ஒரு டேபிள் உள்ளது, அது ஒரே நேரத்தில் இரண்டு பேருக்கு மேல் இருக்க முடியாது. அனைத்து தத்துவஞானிகளுக்கும் உணவளிப்பதே எங்கள் பணி. அவர்களில் யாரும் பசியுடன் இருக்கக்கூடாது, மேஜையில் உட்கார முயற்சிக்கும்போது அவர்களில் யாரும் ஒருவரையொருவர் "தடுக்க" கூடாது (நாம் முட்டுக்கட்டை தவிர்க்க வேண்டும்). எங்கள் தத்துவஞானி வகுப்பு எப்படி இருக்கும் என்பது இங்கே:

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 ("பூட்டப்பட்டது"). அவ்வளவுதான்! நீங்கள் பார்ப்பது போல், இது மிகவும் குழப்பமானதாக இல்லை :) இப்போது, ​​​​இன்டர்நெட்டில் மல்டித்ரெடிங்கை இன்னும் விரிவாகப் படிக்க விரும்பினால், இந்த கருத்துகளை வழிநடத்துவது உங்களுக்கு கொஞ்சம் எளிதாக இருக்கும். அடுத்த பாடங்களில் சந்திப்போம்!