अस्थिर वापरणे

"हाय, अमिगो!"

"हाय, एली!"

"मला तुम्हाला अस्थिर सुधारकाबद्दल सांगायचे आहे. ते काय आहे ते तुम्हाला माहिती आहे का?"

"काहीतरी धाग्यांचे. नक्की आठवत नाहीये."

"मग ऐका. तुमच्यासाठी हे काही तांत्रिक तपशील आहेत:"

"संगणकामध्ये दोन प्रकारची मेमरी असते: ग्लोबल (सामान्य) मेमरी आणि प्रोसेसरमध्ये तयार केलेली मेमरी. अंगभूत प्रोसेसर मेमरी रजिस्टरमध्ये विभागली जाते, प्रथम-स्तरीय कॅशे (L1), द्वितीय-स्तरीय कॅशे (L2) आणि तृतीय-स्तर (L3)."

"या प्रकारच्या मेमरीचा वेग वेगवेगळा असतो. सर्वात वेगवान आणि सर्वात लहान मेमरी म्हणजे रजिस्टर्स, नंतर प्रोसेसर कॅशे (L1, L2, L3), आणि शेवटी ग्लोबल मेमरी (सर्वात कमी)."

"ग्लोबल मेमरी आणि प्रोसेसर कॅशे अत्यंत वेगळ्या वेगाने कार्य करतात, त्यामुळे जावा मशीन प्रत्येक थ्रेडला स्थानिक थ्रेड मेमरीमध्ये (प्रोसेसर कॅशेमध्ये) सर्वाधिक वारंवार वापरले जाणारे व्हेरिएबल्स संचयित करण्याची परवानगी देते."

"ही प्रक्रिया कशीतरी नियंत्रित केली जाऊ शकते?"

"खरंच नाही. सर्व काम जावा मशीनद्वारे केले जाते. परफॉर्मन्स ऑप्टिमाइझ करण्याच्या बाबतीत ते खूप हुशार आहे."

"पण मी तुम्हाला हे का सांगत आहे ते येथे आहे. एक छोटीशी अडचण आहे. जेव्हा दोन थ्रेड्स एकाच व्हेरिएबलसह काम करत असतात, तेव्हा प्रत्येक एक प्रत स्वतःच्या स्थानिक कॅशेमध्ये साठवू शकतो. आणि नंतर एक थ्रेड व्हेरिएबल बदलू शकतो, परंतु दुसरा कदाचित बदल दिसणार नाही, कारण ते अजूनही व्हेरिएबलच्या स्वतःच्या कॉपीसह कार्य करत आहे."

"बरं, मग काय करता येईल?"

"Java च्या निर्मात्यांनी या परिस्थितीसाठी एक विशेष कीवर्ड प्रदान केला आहे: अस्थिर. जर भिन्न थ्रेड्समधून व्हेरिएबल ऍक्सेस केले असेल, तर तुम्हाला ते अस्थिर सुधारकाने चिन्हांकित करणे आवश्यक आहे, त्यामुळे Java मशीन ते कॅशेमध्ये ठेवत नाही. सामान्यतः अशा प्रकारे दिसते:"

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;

"तर, तुम्ही व्हेरिएबलमध्ये प्रवेश करू शकता, परंतु ते बदलणे अद्याप धोकादायक आहे?"

"बरं, तुम्ही ते बदलू शकता, फक्त काळजी घ्या ☺"

"कसे?"

" सिंक्रोनाइझ  हा आमचा सर्वात चांगला मित्र आहे."

"मी बघतो."