ஆவியாகும் தன்மையைப் பயன்படுத்துதல்

"வணக்கம், அமிகோ!"

"ஹாய், எல்லி!"

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

"ஏதோ த்ரெட்ஸுடன் தொடர்புடையது. எனக்கு சரியாக நினைவில்லை."

"அப்படியானால் கேளுங்கள். உங்களுக்கான சில தொழில்நுட்ப விவரங்கள்:"

"கணினியில் இரண்டு வகையான நினைவகம் உள்ளது: உலகளாவிய (சாதாரண) நினைவகம் மற்றும் நினைவகம் செயலியில் கட்டமைக்கப்பட்டுள்ளது. உள்ளமைக்கப்பட்ட செயலி நினைவகம் பதிவுகளாக பிரிக்கப்பட்டுள்ளது, முதல் நிலை கேச் (L1), இரண்டாம் நிலை கேச் (L2) மற்றும் மூன்றாம் நிலை (L3)."

"இந்த வகையான நினைவகங்கள் வெவ்வேறு வேகங்களைக் கொண்டுள்ளன. வேகமான மற்றும் சிறிய நினைவகம் பதிவேடுகள், பின்னர் செயலி கேச் (L1, L2, L3) மற்றும் இறுதியாக உலகளாவிய நினைவகம் (மெதுவானது)."

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

"இந்த செயல்முறையை எப்படியாவது கட்டுப்படுத்த முடியுமா?"

"உண்மையில் இல்லை. அனைத்து வேலைகளும் ஜாவா இயந்திரத்தால் செய்யப்படுகிறது. செயல்திறனை மேம்படுத்தும் போது இது மிகவும் புத்திசாலித்தனமானது."

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

"சரி, அப்புறம் என்ன செய்யலாம்?"

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

public volatile int count = 0;

"ஓ, எனக்கு நினைவிருக்கிறது. இதை நீங்கள் ஏற்கனவே குறிப்பிட்டுள்ளீர்கள். இது எனக்கு முன்பே தெரியும்."

"நிச்சயமா செய்வீங்க. ஆனா நான் சொன்னதும்தான் உனக்கு ஞாபகம் வந்தது."

"ஏர், நான் கொஞ்சம் மறந்துவிட்டேன்."

"மீண்டும் கூறுவது கற்றலின் தாய்!"

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

"என்ன வித்தியாசம்?"

"ஒரு மாறி எவ்வாறு மாற்றப்படுகிறது என்பதைப் பாருங்கள்:"

count++

register = count;

register = register+1;

count = register;

"ஆஹா! அதனால், அனைத்து மாறிகளும் செயலியில் மட்டுமே மாற்றப்படுகின்றனவா?"

"ஆமாம்."

"மற்றும் மதிப்புகள் முன்னும் பின்னுமாக நகலெடுக்கப்படுகின்றன: நினைவகத்திலிருந்து செயலி மற்றும் பின்னோக்கி?"

"ஆமாம்."

"மாறி எண்ணிக்கையை அணுகும்போது அது நினைவகத்திலிருந்து (படி 1) படிக்கப்படும் என்று ஆவியாகும் மாற்றியானது உத்தரவாதம் அளிக்கிறது. மேலும் ஒரு நூல் புதிய மதிப்பை ஒதுக்க விரும்பினால், அது நிச்சயமாக உலகளாவிய நினைவகத்தில் இருக்கும் (படி 3)."

"ஆனால் 1 மற்றும் 3 படிகளுக்கு இடையில் எந்த நூலும் மாறாது என்று ஜாவா இயந்திரம் உத்தரவாதம் அளிக்கவில்லை."

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

"ஆம்."

"இரண்டு இழைகள் ஒரே நேரத்தில் எண்ணிக்கை ++ ஐ இயக்க விரும்பினால், அவை ஒன்றுக்கொன்று குறுக்கிட முடியுமா?"

"ஆம், பாருங்கள்:"

register1 = count;
register1++;
count = register1;

register2 = count;
register2++;
count = register2;

register1 = count;
register2 = count;
register2++;
count = register2;
register1++;
count = register1;

"எனவே, நீங்கள் மாறியை அணுகலாம், ஆனால் அதை மாற்றுவது இன்னும் ஆபத்தானதா?"

"சரி, நீங்கள் அதை மாற்றலாம், கவனமாக இருங்கள் ☺"

"எப்படி?"

" ஒத்திசைக்கப்பட்டவர்  எங்கள் சிறந்த நண்பர்."

"நான் பார்க்கிறேன்."