நூல்கள் சுதந்திரமானவை அல்ல! ஒத்திசைக்கப்பட்டது!

"ஹலோ, அமிகோ! எங்களிடம் ஒரு சஞ்சீவி-எல்லா நோய்களுக்கும் தீர்வு இருக்கிறது. நாம் ஏற்கனவே பார்த்தது போல், கட்டுப்பாடற்ற நூல் மாறுதல் ஒரு பிரச்சனை."

"அடுத்த திரிக்கு எப்போது மாற வேண்டும் என்பதை ஏன் த்ரெட்களால் தீர்மானிக்க முடியாது? அவர்கள் செய்ய வேண்டிய அனைத்தையும் செய்துவிட்டு, "நான் முடித்துவிட்டேன்!"

"மாறுதலைக் கட்டுப்படுத்த த்ரெட்களைத் தாங்களே அனுமதிப்பது இன்னும் பெரிய பிரச்சனையாக இருக்கும். உங்களிடம் மோசமாக எழுதப்பட்ட குறியீடு உள்ளது என்று வைத்துக்கொள்வோம், மேலும் அந்த நூல் CPU-ஐ ஒருபோதும் ஒப்படைக்காது. அன்று, இது இப்படித்தான் செயல்பட்டது. அது ஒரு பயங்கரமான கனவாக இருந்தது."

"சரி. அதனால் என்ன தீர்வு?"

" மற்ற இழைகளைத் தடுப்பது.  இப்படித்தான் செயல்படுகிறது."

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

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

ஒரு நூலுக்கு மற்ற த்ரெட்களுடன் பகிரப்பட்ட ஒரு பொருள் தேவைப்படும்போது, ​​அது பொருளுடன் தொடர்புடைய மியூடெக்ஸைச் சரிபார்க்கிறது. மியூடெக்ஸ் திறக்கப்பட்டால், நூல் அதைப் பூட்டி (“ஆக்கிரமிக்கப்பட்டதாக” குறிக்கும்) மற்றும் பகிரப்பட்ட ஆதாரத்தைப் பயன்படுத்தத் தொடங்குகிறது. நூல் அதன் வணிகத்தைச் செய்த பிறகு, மியூடெக்ஸ் திறக்கப்பட்டது ("கிடைக்கிறது" எனக் குறிக்கப்பட்டது).

நூல் பொருளைப் பயன்படுத்த விரும்பினால் மற்றும் மியூடெக்ஸ் பூட்டப்பட்டிருந்தால், அது காத்திருக்கும் போது நூல் தூங்கும். இறுதியாக ஆக்கிரமிப்பு நூலால் மியூடெக்ஸ் திறக்கப்படும் போது, ​​​​நமது நூல் உடனடியாக அதைப் பூட்டி இயங்கத் தொடங்கும். ஒரு குளியலறை கதவு அடையாளத்துடன் ஒப்புமை சரியானது.

"அப்படியானால் நான் எப்படி மியூடெக்ஸ் மூலம் வேலை செய்வது? நான் சிறப்புப் பொருட்களை உருவாக்க வேண்டுமா?"

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

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

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

String s1 = name1; //Ally
name1 = name2; //Lena
name2 = s1; //Ally

String s2 = name1; //Lena
name1 = name2; //Ally
name2 = s2; //Lena

String s1 = name1;
name1 = name2;
//other thread is running
name2 = s1;

//the thread waits until the mutex is unlocked

String s2 = name1;
name1 = name2;
//other thread is running
//other thread is running
name2 = s2;

ஒத்திசைக்கப்பட்ட முக்கிய வார்த்தைக்கு கவனம் செலுத்துங்கள்  .

"ஆமாம், என்ன அர்த்தம்?"

"ஒத்திசைக்கப்பட்டதாகக் குறிக்கப்பட்ட குறியீட்டின் தொகுதிக்குள் ஒரு நூல் நுழையும் போது, ​​ஒத்திசைக்கப்பட்ட வார்த்தைக்குப் பிறகு அடைப்புக்குறிக்குள் சுட்டிக்காட்டப்பட்ட பொருளின் மியூடெக்ஸை ஜாவா இயந்திரம் உடனடியாகப் பூட்டுகிறது. எங்கள் நூல் வெளியேறும் வரை வேறு எந்த நூலும் இந்தத் தொகுதிக்குள் நுழைய முடியாது. எங்கள் நூல் வெளியேறியவுடன் . பிளாக் ஒத்திசைக்கப்பட்டதாகக் குறிக்கப்பட்டது, மியூடெக்ஸ் உடனடியாகத் தானாகவே திறக்கப்பட்டு, மற்றொரு நூலால் பெறப்படும்."

மியூடெக்ஸ் ஆக்கிரமிக்கப்பட்டால், எங்கள் நூல் அசையாமல் நின்று அது விடுவிக்கப்படும் வரை காத்திருக்கும்.

"மிகவும் எளிமையானது மற்றும் நேர்த்தியானது. அது ஒரு அழகான தீர்வு."

"ஆமாம். ஆனால் இந்த விஷயத்தில் என்ன நடக்கும் என்று நினைக்கிறீர்கள்?"

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

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

public void swap2()
{
synchronized (this)
{
String s = name1;
name1 = name2;
name2 = s;
}
}
}

ஒரு நூல் swap முறை என்றும் மற்றொரு நூல் swap2 முறை என்றும் அழைத்தால் என்ன நடக்கும்?

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

"நல்லது, அமிகோ! அதுதான் சரியான பதில்!"

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

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

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

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

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

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

public static void swap2()
{
synchronized (MyClass.class)
{
String s = name1;
name1 = name2;
name2 = s;
}
}