कचरा गोळा करणे

"हाय! मी तुम्हाला कचरा गोळा करण्याबद्दल आणखी एक छोटासा धडा देण्याचे ठरवले आहे."

तुम्हाला आधीच माहिती आहे की, एखादी वस्तू अनावश्यक झाल्यावर जावा मशीन स्वतः निरीक्षण करते आणि ती हटवते.

"हो. तू आणि ऋषी मला याबद्दल आधी सांगितले होते. मला तपशील आठवत नाही."

"ठीक आहे. मग पुन्हा त्यावर जाऊया."

"एखादी वस्तू तयार होताच, JVM त्याच्यासाठी मेमरी वाटप करते. संदर्भ व्हेरिएबल्सचा वापर करून ऑब्जेक्टमधील स्वारस्यांचे परीक्षण केले जाते.  कचरा गोळा करताना एखादी वस्तू हटविली जाऊ शकते, म्हणजे ज्या प्रक्रियेद्वारे मेमरी रिलीझ केली जाते त्या प्रक्रियेचा संदर्भ देणारे कोणतेही व्हेरिएबल्स नसल्यास. वस्तु. "

"मला कचरा गोळा करणाऱ्या बद्दल थोडे सांगा - ते काय आहे आणि ते कसे कार्य करते."

"ठीक आहे. मुख्य थ्रेडवर कचरा गोळा केला जायचा. दर 5 मिनिटांनी किंवा त्याहून अधिक वेळा. जर पुरेशी फ्री मेमरी नसेल, तर Java मशीन सर्व थ्रेड निलंबित करेल आणि न वापरलेल्या वस्तू हटवेल."

"परंतु हा दृष्टिकोन आता सोडून देण्यात आला आहे. पुढील पिढीतील कचरा गोळा करणारे पडद्यामागे आणि वेगळ्या धाग्यावर काम करतात. याला समवर्ती कचरा संकलन म्हणतात."

"मी बघतो. एखादी वस्तू हटवायची की नाही हा निर्णय नेमका कसा होतो?"

"एखाद्या वस्तूच्या संदर्भांची संख्या मोजणे फारसे प्रभावी नाही - अशा वस्तू असू शकतात ज्या एकमेकांना संदर्भ देतात, परंतु इतर कोणत्याही वस्तूंद्वारे संदर्भित नसतात."

"म्हणून Java एक वेगळा दृष्टीकोन घेतो.  Java वस्तूंना पोहोचण्यायोग्य आणि अगम्य मध्ये विभाजित करते.  एखादी वस्तू पोहोचण्यायोग्य (जिवंत) असते जर ती दुसर्‍या पोहोचण्यायोग्य (जिवंत) ऑब्जेक्टद्वारे संदर्भित असेल. पोहोचण्यायोग्यता थ्रेड्सवरून निर्धारित केली जाते. धावणारे थ्रेड नेहमी पोहोचण्यायोग्य (जिवंत) मानले जातात. , जरी कोणी त्यांचा संदर्भ देत नसला तरीही."

"ठीक आहे. मला वाटतं मला पटलं."

"वास्तविक कचरा संकलन कसे होते - अनावश्यक वस्तू हटवणे?"

"हे सोपे आहे. Java मध्ये, मेमरी दोन भागांमध्ये विभागली जाते, आणि जेव्हा कचरा गोळा करण्याची वेळ येते, तेव्हा सर्व जिवंत (पोहोचण्यायोग्य) वस्तू मेमरीच्या दुसर्या भागात कॉपी केल्या जातात आणि जुनी मेमरी सर्व सोडली जाते."

"तो एक मनोरंजक दृष्टीकोन आहे. संदर्भ मोजण्याची गरज नाही: सर्व पोहोचण्यायोग्य वस्तू कॉपी करा आणि बाकी सर्व कचरा आहे."

"हे त्यापेक्षा थोडे अधिक क्लिष्ट आहे. जावा प्रोग्रामरना असे आढळले की ऑब्जेक्ट्स सहसा दोन श्रेणींमध्ये विभागल्या जातात: दीर्घायुषी (जे प्रोग्राम चालू असताना संपूर्ण वेळ अस्तित्वात असतात) आणि अल्पायुषी (जे पद्धतींमध्ये आणि कार्यप्रदर्शनासाठी आवश्यक असतात «स्थानिक » ऑपरेशन्स)."

"दीर्घकाळ टिकणाऱ्या वस्तूंना अल्पायुषी वस्तूंपासून वेगळे ठेवणे अधिक कार्यक्षम आहे. हे करण्यासाठी, त्या वस्तूचे दीर्घायुष्य निश्चित करण्याचा मार्ग शोधणे आवश्यक होते."

"म्हणून, त्यांनी सर्व मेमरी «पिढ्या» मध्ये विभागली. पहिल्या पिढीतील वस्तू, दुसऱ्या पिढीच्या वस्तू इ. प्रत्येक वेळी मेमरी साफ केल्यावर जनरेशन काउंटर १ ने वाढवला जातो. जर काही वस्तू अनेक पिढ्यांमध्ये अस्तित्वात असतील, तर त्या दीर्घायुषी म्हणून नोंदवले जातात."

"आज, कचरा गोळा करणारा जावाचा एक अतिशय क्लिष्ट आणि कार्यक्षम भाग आहे. त्याचे बरेच भाग हेअरिस्टली काम करतात-अल्गोरिदमवर आधारित जे अंदाज लावतात. परिणामी, तो अनेकदा वापरकर्त्याचे ऐकत नाही."

"म्हणजे?"

"जावामध्ये कचरा संकलक ( GC ) ऑब्जेक्ट आहे ज्याला System.gc () पद्धत वापरून कॉल केले जाऊ शकते."

"तुम्ही System.runFinalization() चा वापर करून कॉल्सना हटवल्या जाणाऱ्या ऑब्जेक्ट्सच्या अंतिम पद्धतींसाठी सक्ती करू शकता. परंतु वस्तुस्थिती अशी आहे की, Java दस्तऐवजीकरणानुसार, ही हमी ना कचरा गोळा करणे सुरू होईल किंवा अंतिम रूप दिले जाईल ( ) पद्धत कॉल केली जाईल.  कचरा वेचक कधी आणि कशावर कॉल करायचा हे ठरवतो. "

"अरे! जाणून छान आहे."

"परंतु आणखी काही आहे. तुम्हाला माहिती आहे की, Java मध्ये, काही वस्तू इतरांचा संदर्भ देतात. संदर्भांचे हे नेटवर्क ऑब्जेक्ट हटवायचे की नाही हे निर्धारित करण्यासाठी वापरले जाते."

"आणि बघा. Java चे विशेष संदर्भ आहेत जे तुम्हाला या प्रक्रियेवर प्रभाव पाडू देतात. त्यांच्यासाठी विशेष रॅपर वर्ग आहेत. ते येथे आहेत:"

" सॉफ्टरेफरन्स  हा एक मऊ संदर्भ आहे."

" कमकुवत संदर्भ  एक कमकुवत संदर्भ आहे."

" फॅंटमरेफरन्स हा एक फॅंटम संदर्भ आहे."

"अरे... हे मला आतील वर्ग, नेस्टेड क्लासेस, नेस्टेड निनावी क्लासेस आणि स्थानिक क्लासेसची आठवण करून देतात. नावे वेगळी आहेत, पण ते कशासाठी आहेत हे अजिबात स्पष्ट नाही."

"सांग, अमिगो, तुम्ही प्रोग्रामर झाला आहात. आता तुम्हाला वर्गाच्या नावांमुळे राग आला आहे, "ते पुरेशी माहितीपूर्ण नाहीत, आणि हा वर्ग काय करतो, कसे, हे एका नावाने (!) ठरवणे अशक्य आहे. आणि का"."

"व्वा. माझ्या लक्षातही आलं नाही. पण हे अगदी स्पष्ट आहे."

"ठीक आहे. पुरेसे शब्द. मी तुम्हाला SoftReferences बद्दल सांगतो."

"हे संदर्भ विशेषत: कॅशिंगसाठी डिझाइन केले होते, जरी ते इतर हेतूंसाठी वापरले जाऊ शकतात - सर्व प्रोग्रामरच्या विवेकबुद्धीनुसार."

"अशा संदर्भाचे एक उदाहरण येथे आहे:"

// Create a Cat object
Cat cat = new Cat();

// Create a soft reference to a Cat object
SoftReference<Cat> catRef = new SoftReference<Cat>(cat);

// Now only the catRef soft reference points at the object
cat = null;

// Now the ordinary cat variable also references the object
cat = catRef.get();

// Clear the soft reference
catRef.clear();

"एखाद्या वस्तूचे फक्त संदर्भ मऊ असतील तर ती जगत राहते आणि त्याला 'सॉफ्ट-रिचेबल' म्हणतात."

"परंतु!  प्रोग्रामकडे पुरेशी मेमरी नसल्यास केवळ सॉफ्ट रेफरन्सद्वारे संदर्भित ऑब्जेक्ट कचरा कलेक्टरद्वारे हटविला जाऊ शकतो. अचानक प्रोग्राममध्ये पुरेशी मेमरी नसल्यास, OutOfMemoryException  टाकण्यापूर्वी , कचरा संग्राहक सर्व ऑब्जेक्ट हटवेल. सॉफ्ट रेफरन्सद्वारे संदर्भित आणि प्रोग्रामला मेमरी वाटप करण्याचा पुन्हा प्रयत्न करेल."

"समजा, क्लायंट प्रोग्राम वारंवार सर्व्हर प्रोग्रामकडून विविध डेटाची विनंती करतो. सर्व्हर प्रोग्राम सॉफ्टरेफरन्सचा वापर करून त्यातील काही कॅशे करू शकतो. जर सॉफ्ट रेफरन्सने मृत्यूपासून दूर ठेवलेल्या वस्तू मेमरीचा मोठा भाग घेतात, तर कचरा गोळा करणारा त्यांना हटवतो. सर्व. ते सुंदर आहे!"

"हो. मला स्वतःला आवडले."

"ठीक आहे, एक लहानशी जोड: SoftReference क्लासमध्ये दोन पद्धती आहेत. get() पद्धत SoftReference द्वारे संदर्भित ऑब्जेक्ट परत करते . जर कचरा कलेक्टरद्वारे ऑब्जेक्ट हटवला गेला असेल, तर get () पद्धत अचानक नल रिटर्न सुरू करेल."

"उपयोगकर्ता clear() मेथडला कॉल करून स्पष्टपणे सॉफ्टरेफरन्स साफ करू शकतो. या प्रकरणात, SoftReference ऑब्जेक्टमधील कमकुवत लिंक नष्ट केली जाईल."

"सध्या एवढेच."

"रंजक कथेबद्दल धन्यवाद, एली. ती खरोखर खूप मनोरंजक होती."