நூல் ஒத்திசைவு. ஒத்திசைக்கப்பட்ட ஆபரேட்டர்

வணக்கம்! இன்று நாம் மல்டித்ரெட் புரோகிராமிங்கின் அம்சங்களை தொடர்ந்து கருத்தில் கொள்வோம் மற்றும் நூல் ஒத்திசைவு பற்றி பேசுவோம்.

ஜாவாவில் ஒத்திசைவு என்றால் என்ன?

நிரலாக்க டொமைனுக்கு வெளியே, இது இரண்டு சாதனங்கள் அல்லது நிரல்களை ஒன்றாகச் செயல்பட அனுமதிக்கும் ஏற்பாட்டைக் குறிக்கிறது. எடுத்துக்காட்டாக, ஒரு ஸ்மார்ட்போன் மற்றும் கணினியை Google கணக்குடன் ஒத்திசைக்க முடியும், மேலும் இணையதளக் கணக்கை சமூக வலைப்பின்னல் கணக்குகளுடன் ஒத்திசைக்க முடியும், எனவே நீங்கள் உள்நுழைவதற்கு அவற்றைப் பயன்படுத்தலாம். நூல் ஒத்திசைவுக்கு இதே போன்ற அர்த்தம் உள்ளது: இது நூல்கள் தொடர்பு கொள்ளும் ஒரு ஏற்பாடாகும். ஒருவருக்கொருவர். முந்தைய பாடங்களில், எங்கள் நூல்கள் ஒருவருக்கொருவர் தனித்தனியாக வாழ்ந்து வேலை செய்தன. ஒருவர் கணக்கீடு செய்தார், இரண்டாவது தூங்கினார், மூன்றில் ஒருவர் கன்சோலில் எதையாவது காட்டினார், ஆனால் அவர்கள் தொடர்பு கொள்ளவில்லை. உண்மையான திட்டங்களில், இத்தகைய சூழ்நிலைகள் அரிதானவை. ஒரே தரவுத் தொகுப்பில் பல நூல்கள் செயலில் செயல்படலாம் மற்றும் மாற்றலாம். இது பிரச்சனைகளை உருவாக்குகிறது. ஒரே இடத்தில் உரையை எழுதும் பல நூல்களை கற்பனை செய்து பாருங்கள், எடுத்துக்காட்டாக, ஒரு உரை கோப்பு அல்லது கன்சோலுக்கு. இந்த வழக்கில், கோப்பு அல்லது பணியகம் பகிரப்பட்ட ஆதாரமாக மாறும். இழைகள் ஒன்றுக்கொன்று இருப்பதைப் பற்றி அறியாததால், நூல் அட்டவணையாளரால் தங்களுக்கு ஒதுக்கப்பட்ட நேரத்தில் தங்களால் முடிந்த அனைத்தையும் எழுதுகின்றன. சமீபத்திய பாடத்தில், இது எங்கு செல்கிறது என்பதற்கான உதாரணத்தைக் கண்டோம். அதை இப்போது நினைவு கூர்வோம்: த்ரெட்கள் தங்கள் செயல்களை ஒன்றோடொன்று ஒருங்கிணைக்காமல் பகிரப்பட்ட வளத்துடன் (கன்சோல்) வேலை செய்வதே காரணம். த்ரெட்-1க்கு த்ரெட் ஷெட்யூலர் நேரத்தை ஒதுக்கினால், அது உடனடியாக எல்லாவற்றையும் கன்சோலில் எழுதும். வேறு என்ன நூல்கள் உள்ளன அல்லது ஏற்கனவே எழுத முடியவில்லை என்பது முக்கியமல்ல. இதன் விளைவாக, நீங்கள் பார்க்க முடியும் என, மனச்சோர்வு. அதனால்தான் அவர்கள் ஒரு சிறப்புக் கருத்தை அறிமுகப்படுத்தினர், மியூடெக்ஸ் (பரஸ்பர விலக்கு) , மல்டித்ரெட் நிரலாக்கத்திற்கு. ஒரு மியூடெக்ஸின் நோக்கம்ஒரு குறிப்பிட்ட நேரத்தில் ஒரு பொருளுக்கு ஒரே ஒரு நூல் மட்டுமே அணுகக்கூடிய வகையில் ஒரு பொறிமுறையை வழங்குவதாகும். த்ரெட்-1 ஆப்ஜெக்ட் A இன் மியூடெக்ஸைப் பெற்றால், மற்ற த்ரெட்களால் அப்ஜெக்டை அணுகவும் மாற்றவும் முடியாது. ஆப்ஜெக்ட் A இன் மியூடெக்ஸ் வெளியிடப்படும் வரை மற்ற இழைகள் காத்திருக்க வேண்டும். வாழ்க்கையிலிருந்து ஒரு எடுத்துக்காட்டு: நீங்களும் 10 அந்நியர்களும் ஒரு பயிற்சியில் பங்கேற்கிறீர்கள் என்று கற்பனை செய்து பாருங்கள். மாறி மாறி, நீங்கள் உங்கள் கருத்துக்களை வெளிப்படுத்த வேண்டும் மற்றும் ஏதாவது விவாதிக்க வேண்டும். ஆனால் நீங்கள் ஒருவரையொருவர் முதன்முறையாகப் பார்ப்பதால், தொடர்ந்து ஒருவரையொருவர் குறுக்கிட்டு ஆத்திரத்தில் பறக்காமல் இருக்க, நீங்கள் 'பேசும் பந்தை' பயன்படுத்துகிறீர்கள்: பந்தைக் கொண்டவர் மட்டுமே பேச முடியும். இந்த வழியில் நீங்கள் ஒரு நல்ல மற்றும் பயனுள்ள விவாதத்தை முடிக்கிறீர்கள். அடிப்படையில், பந்து ஒரு மியூடெக்ஸ் ஆகும். ஒரு பொருளின் மியூடெக்ஸ் ஒரு நூலின் கையில் இருந்தால், மற்ற இழைகள் பொருளுடன் வேலை செய்ய முடியாது.Objectவர்க்கம், அதாவது ஜாவாவில் உள்ள ஒவ்வொரு பொருளுக்கும் ஒன்று உள்ளது.

ஒத்திசைக்கப்பட்ட ஆபரேட்டர் எவ்வாறு செயல்படுகிறது

ஒரு புதிய முக்கிய சொல்லை பற்றி தெரிந்து கொள்வோம்: ஒத்திசைக்கப்பட்ட . இது ஒரு குறிப்பிட்ட குறியீட்டு தொகுதியைக் குறிக்கப் பயன்படுகிறது. குறியீட்டுத் தொகுதியானது முக்கிய சொல்லைக் கொண்டு குறிக்கப்பட்டிருந்தால் synchronized, அந்தத் தொகுதியை ஒரு நேரத்தில் ஒரு நூலால் மட்டுமே செயல்படுத்த முடியும். ஒத்திசைவை வெவ்வேறு வழிகளில் செயல்படுத்தலாம். எடுத்துக்காட்டாக, ஒரு முழு முறையையும் ஒத்திசைக்க வேண்டும் என்று அறிவிப்பதன் மூலம்:

public synchronized void doSomething() {

   // ...Method logic
}

அல்லது சில பொருளைப் பயன்படுத்தி ஒத்திசைவு செய்யப்படும் குறியீட்டுத் தொகுதியை எழுதவும்:

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...Some logic available simultaneously to all threads

       synchronized (obj) {

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

பொருள் எளிமையானது. முக்கிய வார்த்தையால் குறிக்கப்பட்ட குறியீடு தொகுதிக்குள் ஒரு நூல் சென்றால் synchronized, அது பொருளின் மியூடெக்ஸை உடனடியாகப் பிடிக்கும், மேலும் அதே தொகுதி அல்லது முறையை உள்ளிட முயற்சிக்கும் மற்ற அனைத்து த்ரெட்களும் முந்தைய நூல் அதன் வேலையை முடித்து மானிட்டரை வெளியிடும் வரை காத்திருக்க வேண்டிய கட்டாயத்தில் உள்ளது. மூலம்! பாடத்திட்டத்தின் போது, ​​நீங்கள் ஏற்கனவே உதாரணங்களைப் பார்த்திருக்கிறீர்கள் synchronized, ஆனால் அவை வித்தியாசமாகத் தெரிந்தன:

public void swap()
{
   synchronized (this)
   {
       // ...Method logic
   }
}

தலைப்பு உங்களுக்கு புதியது. மற்றும், நிச்சயமாக, தொடரியல் குழப்பம் இருக்கும். எனவே, அதை எழுதும் வெவ்வேறு வழிகளால் பின்னர் குழப்பமடையாமல் இருக்க உடனடியாக அதை மனப்பாடம் செய்யுங்கள். எழுதும் இந்த இரண்டு வழிகளும் ஒரே பொருளைக் குறிக்கின்றன:

public void swap() {

   synchronized (this)
   {
       // ...Method logic
   }
}


public synchronized void swap() {

   }
}

முதல் வழக்கில், முறையை உள்ளிடும்போது உடனடியாக ஒத்திசைக்கப்பட்ட குறியீட்டை உருவாக்குகிறீர்கள். இது பொருளால் ஒத்திசைக்கப்படுகிறது this, அதாவது தற்போதைய பொருள். இரண்டாவது எடுத்துக்காட்டில், synchronizedமுழு முறைக்கும் முக்கிய சொல்லைப் பயன்படுத்துகிறீர்கள். இது ஒத்திசைவுக்குப் பயன்படுத்தப்படும் பொருளை வெளிப்படையாகக் குறிப்பிடுவது தேவையற்றதாக்குகிறது. முழு முறையும் முக்கிய சொல்லுடன் குறிக்கப்பட்டுள்ளதால், வகுப்பின் அனைத்து நிகழ்வுகளுக்கும் முறை தானாகவே ஒத்திசைக்கப்படும். எந்த வழி சிறந்தது என்பது பற்றிய விவாதத்தில் நாங்கள் மூழ்க மாட்டோம். இப்போதைக்கு, நீங்கள் விரும்பும் வழியைத் தேர்வுசெய்க :) முக்கிய விஷயம் நினைவில் கொள்ள வேண்டும்: ஒரு முறையின் அனைத்து தர்க்கங்களும் ஒரு நேரத்தில் ஒரு நூல் மூலம் செயல்படுத்தப்படும் போது மட்டுமே நீங்கள் ஒரு முறையை ஒத்திசைக்க முடியும். எடுத்துக்காட்டாக, பின்வரும் முறையை ஒத்திசைப்பது தவறு doSomething():

public class Main {

   private Object obj = new Object();

   public void doSomething() {

       // ...Some logic available simultaneously to all threads

       synchronized (obj) {

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

நீங்கள் பார்க்க முடியும் என, முறையின் ஒரு பகுதி ஒத்திசைவு தேவையில்லாத தர்க்கத்தைக் கொண்டுள்ளது. அந்தக் குறியீட்டை ஒரே நேரத்தில் பல த்ரெட்களால் இயக்க முடியும், மேலும் அனைத்து முக்கியமான இடங்களும் தனித் தொகுதியில் அமைக்கப்படும் synchronized. மேலும் ஒரு விஷயம். பெயர் மாற்றத்துடன் பாடத்தில் இருந்து நமது உதாரணத்தை கூர்ந்து ஆராய்வோம்:

public void swap()
{
   synchronized (this)
   {
       // ...Method logic
   }
}

குறிப்பு: பயன்படுத்தி ஒத்திசைவு செய்யப்படுகிறதுthis. அதாவது, ஒரு குறிப்பிட்டMyClassபொருளைப் பயன்படுத்துதல். எங்களிடம் 2 நூல்கள் (Thread-1மற்றும்Thread-2) மற்றும் ஒரே ஒருMyClass myClassபொருள் மட்டுமே உள்ளது என்று வைத்துக்கொள்வோம். இந்த வழக்கில்,Thread-1அழைத்தால்myClass.swap(), பொருளின் மியூடெக்ஸ் பிஸியாக இருக்கும், மேலும் அழைக்க முயற்சிக்கும் போது,​​மியூடெக்ஸ் வெளியிடப்படும் வரை காத்திருக்கும்போதுmyClass.swap()முறைஎங்களிடம் 2 நூல்கள் மற்றும் 2 பொருள்கள் (மற்றும்Thread-2இருந்தால், வெவ்வேறு பொருள்களில் ஒரே நேரத்தில் ஒத்திசைக்கப்பட்ட முறைகளை எங்கள் த்ரெட்கள் எளிதாக செயல்படுத்தும். முதல் நூல் இதை செயல்படுத்துகிறது: MyClassmyClass1myClass2

myClass1.swap();

இரண்டாவது இதை செயல்படுத்துகிறது:

myClass2.swap();

இந்த வழக்கில், ஒரு குறிப்பிட்ட பொருளைப் பயன்படுத்தி ஒத்திசைவு செய்யப்படுவதால், முறையின் synchronizedஉள்ளே உள்ள முக்கிய சொல் swap()நிரலின் செயல்பாட்டை பாதிக்காது. பிந்தைய வழக்கில், எங்களிடம் 2 பொருள்கள் உள்ளன. இதனால், நூல்கள் ஒன்றுக்கொன்று பிரச்சனைகளை உருவாக்காது. எல்லாவற்றிற்கும் மேலாக, இரண்டு பொருள்கள் 2 வெவ்வேறு மியூடெக்ஸ்களைக் கொண்டுள்ளன, மேலும் ஒன்றைப் பெறுவது மற்றொன்றைப் பெறுவதில் இருந்து சுயாதீனமானது .

நிலையான முறைகளில் ஒத்திசைவின் சிறப்பு அம்சங்கள்

ஆனால் நீங்கள் ஒரு நிலையான முறையை ஒத்திசைக்க வேண்டும் என்றால் என்ன செய்வது ?

class MyClass {
   private static String name1 = "Ally";
   private static String name2 = "Lena";

   public static synchronized void swap() {
       String s = name1;
       name1 = name2;
       name2 = s;
   }

}

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

class MyClass {
   private static String name1 = "Ally";
   private static String name2 = "Lena";

   public static void swap() {

       synchronized (MyClass.class) {
           String s = name1;
           name1 = name2;
           name2 = s;
       }
   }

}

கொள்கையளவில், இதைப் பற்றி நீங்களே யோசித்திருக்கலாம்: பொருள்கள் எதுவும் இல்லாததால், ஒத்திசைவு பொறிமுறையை எப்படியாவது வகுப்பிலேயே சுட வேண்டும். அதுதான் வழி: ஒத்திசைக்க வகுப்புகளைப் பயன்படுத்தலாம்.