what is garbage collection java
यह ट्यूटोरियल बताता है कि जावा में कचरा संग्रह क्या है और कचरा कलेक्टर कैसे काम करता है। आप कचरा संग्रह के लिए एल्गोरिदम के बारे में भी जानेंगे:
जो पाठक C / C ++ के जानकार हैं, उन्हें इस बात की जानकारी होनी चाहिए कि C / C ++ में ऑब्जेक्ट्स बनाना और डिलीट करना प्रोग्रामर की जिम्मेदारी है।
यदि प्रोग्रामर निर्मित वस्तुओं को नष्ट करना भूल जाता है तो गंभीर त्रुटियां उत्पन्न होती हैं। इसका कारण यह है कि वस्तुओं को नष्ट करने में विफल होने के कारण ' स्मृति से बाहर 'त्रुटियों, स्मृति लीक, आदि।
जावा में इस स्थिति का पूरी तरह से ध्यान रखा जाता है क्योंकि ऑब्जेक्ट्स का ट्रैक रखने के लिए प्रोग्रामर की कोई आवश्यकता नहीं होती है। जावा स्वचालित कचरा संग्रह के माध्यम से हमारे लिए वस्तु विनाश का ख्याल रखता है।
=> स्क्रैच से जावा जानने के लिए यहां जाएं।
वह प्रक्रिया जिसके द्वारा अब उपयोग में नहीं आने वाली वस्तुओं को ढेर मेमोरी से हटा दिया जाता है, उसे 'कचरा संग्रह' कहा जाता है। कचरा संग्रहण तकनीक जावा में मेमोरी प्रबंधन का एक हिस्सा है।
इस प्रकार जावा में, गारबेज कलेक्टर उन सभी वस्तुओं को नष्ट कर देता है जो अब उपयोग में नहीं हैं।
आप क्या सीखेंगे:
- जावा में एक कचरा कलेक्टर क्या है?
- जावा में कचरा संग्रहण कैसे काम करता है?
- कचरा संग्रह एल्गोरिदम जावा में
- निष्कर्ष
जावा में एक कचरा कलेक्टर क्या है?
जावा में कचरा संग्रह का प्रबंधन कचरा कलेक्टर नामक कार्यक्रम द्वारा किया जाता है।
कचरा कलेक्टर को एक प्रोग्राम के रूप में परिभाषित किया जा सकता है जिसका उपयोग ऑब्जेक्ट डी-आवंटन को संभालकर मेमोरी को स्वचालित रूप से प्रबंधित करने के लिए किया जाता है।
हम जानते हैं कि जावा भाषा में, नए ऑब्जेक्ट को नए ऑपरेटर का उपयोग करके बनाया और आवंटित किया जाता है। किसी नए ऑपरेटर का उपयोग करके किसी ऑब्जेक्ट को आवंटित की गई मेमोरी तब तक आवंटित की जाती है जब तक कि संदर्भ इस ऑब्जेक्ट का उपयोग नहीं कर रहे हैं।
जैसे ही संदर्भों का अस्तित्व समाप्त हो जाता है, स्मृति जिस वस्तु पर रहती है वह पुनः प्राप्त हो जाती है। जावा तब स्वचालित रूप से वस्तुओं के डी-आवंटन या विनाश को संभालता है और हमें ऑब्जेक्ट को स्पष्ट रूप से नष्ट करने की आवश्यकता नहीं है।
यह तकनीक जावा में गारबेज कलेक्शन तकनीक है, जहां प्रोग्रामर को वस्तुओं के निपटान को स्पष्ट रूप से संभालने की आवश्यकता नहीं है।
ध्यान दें कि यदि प्रोग्राम को मेमोरी को डी-आवंटित नहीं करते हैं जब ऑब्जेक्ट्स को इसकी आवश्यकता नहीं होती है, तो अंततः आवंटित करने के लिए कोई मेमोरी नहीं बचेगी और प्रोग्राम क्रैश हो जाएंगे। इस स्थिति को मेमोरी लीक कहा जाता है।
कचरा संग्रहकर्ता हमेशा डेमॉन थ्रेड पर पृष्ठभूमि में चलता है। गारबेज कलेक्टर को डेमन थ्रेड का सबसे अच्छा उदाहरण माना जाता है।
ढेर कलेक्टर स्मृति ढेर जारी करने का इरादा रखता है। यह उन वस्तुओं को नष्ट करके करता है जो 'अगम्य' हैं।
एक 'अप्राप्य' वस्तु क्या है?
कोई वस्तु अप्राप्य हो जाती है जब उससे जुड़ा एक भी संदर्भ नहीं होता है।
निम्नलिखित कोड पर विचार करें:
Integer ref_obj = new Integer (5); //ref_obj is a reference to Integer ref_obj = null; //Integer object now becomes unreachable
जैसा कि ऊपर दिए गए कोड से देखा जाता है, एक वस्तु तब तक पहुंच सकती है जब तक कि कोई संदर्भ उसके साथ जुड़ा हुआ है। जिस समय संदर्भ एसोसिएशन को हटा दिया जाता है (उपरोक्त मामले में अशक्त करने के लिए एक सेटिंग संदर्भ) वस्तु पहुंच से बाहर हो जाती है।
जब कोई वस्तु अप्राप्य हो जाती है, तो वह कचरा संग्रहण (GC) के लिए योग्य हो जाती है।
हम किसी वस्तु को GC के योग्य कैसे बना सकते हैं?
यद्यपि प्रोग्रामर को ऑब्जेक्ट्स को नष्ट करने की आवश्यकता नहीं होती है क्योंकि उन्हें GC द्वारा ध्यान रखा जाता है, कम से कम प्रोग्रामर इन ऑब्जेक्ट्स को अप्राप्य बना सकता है जब उन्हें अब आवश्यकता नहीं होती है।
ऐसा करने से, जीसी अप्राप्य वस्तुओं को इकट्ठा करेगा और उन्हें नष्ट कर देगा।
जीसी के लिए किसी वस्तु को योग्य बनाने के कुछ तरीके हैं जो इसे अप्राप्य बना सकते हैं।
वे:
(1) संदर्भ को निरूपित करें
किसी ऑब्जेक्ट को सौंपे गए संदर्भ को देखते हुए, यदि इस ऑब्जेक्ट की अब आवश्यकता नहीं है, तो संदर्भ को अशक्त करने के लिए असाइन करें।
Student s = new Student (); s = null;
जब s को शून्य पर सेट किया जाता है, तो छात्र ऑब्जेक्ट अप्राप्य हो जाता है।
# 2) संदर्भ को फिर से असाइन करें
यह वस्तुओं को जीसी के लिए योग्य बनाने का एक और तरीका है।
निम्नलिखित कोड पर विचार करें।
Student s1 = new Student (); Student s2 = new Student (); s1 = s2;
अब जैसा कि हमने s1 को किसी अन्य ऑब्जेक्ट को असाइन किया है, s1 द्वारा संदर्भित छात्र ऑब्जेक्ट dereferenced है।
# 3) एक अनाम वस्तु बनाएं
एक अनाम वस्तु बनाकर हम वस्तुओं को जीसी के लिए योग्य बना सकते हैं।
हम नीचे दिखाए गए अनुसार एक अनाम वस्तु बना सकते हैं:
new Student();
एक बार जब हम वस्तुओं को GC के लिए योग्य बनाते हैं, तो ये वस्तुएं GC द्वारा तुरंत नष्ट हो सकती हैं या नहीं भी। ऐसा इसलिए है क्योंकि हम जब और जब चाहें जीसी को क्रियान्वित करने के लिए स्पष्ट रूप से बाध्य नहीं कर सकते।
कचरा कलेक्टर कब चलता है?
कचरा संग्रहण कार्यक्रम चलाने के लिए जेवीएम पर निर्भर है। जब जेवीएम कचरा संग्राहक चलाता है, तो अप्राप्य वस्तुएँ नष्ट हो जाती हैं। लेकिन फिर भी, हम गारंटी नहीं दे सकते कि JVM कब चलेगा।
यद्यपि हम GC को निष्पादित करने के लिए बाध्य नहीं कर सकते हैं, हम एक कचरा संग्रह के लिए बहुत अच्छी तरह से अनुरोध कर सकते हैं।
निम्न विधियों में से किसी का उपयोग करके जीसी का अनुरोध किया जा सकता है।
# 1) System.gc (): जावा का सिस्टम वर्ग एक स्थिर विधि gc () प्रदान करता है, जिसके प्रयोग से हम JVM को कचरा संग्राहक चलाने के लिए अनुरोध कर सकते हैं।
# 2) Runtime.getRuntime ()। Gc (): System.gc () की तरह, हम JVM को कचरा संग्राहक चलाने के लिए अनुरोध करने के लिए 'रनटाइम क्लास' के gc () पद्धति का भी उपयोग कर सकते हैं।
ध्यान दें: इस बात की कोई गारंटी नहीं है कि इन दोनों विधियों के अनुरोध के बाद कचरा कलेक्टर चलेगा।
अंतिम रूप
वस्तुओं को नष्ट करने से ठीक पहले गारबेज कलेक्टर द्वारा अंतिम रूप दिया जाता है। अंतिम रूप देने की तकनीक के एक हिस्से के रूप में, गारबेज कलेक्टर ऑब्जेक्ट पर अंतिम रूप () विधि कहता है। अंतिम क्रिया () विधि का उपयोग सफाई गतिविधियों को करने के लिए किया जाता है।
अंतिम () विधि 'ऑब्जेक्ट' वर्ग द्वारा प्रदान की गई है और इसमें निम्नलिखित प्रोटोटाइप है।
protected void finalize () throws Throwable
जब भी ऑब्जेक्ट कचरा एकत्र किया जाता है तो अंतिम रूप () विधि लागू की जाती है
ध्यान दें: कचरा संग्रहकर्ता केवल उन वस्तुओं को इकट्ठा करता है जो नए कीवर्ड का उपयोग करके बनाई गई हैं। अन्य वस्तुओं के लिए, हमें सफाई करने के लिए अंतिम () विधि का उपयोग करना होगा।
नीचे दिए गए कार्यक्रम में जावा में एक सरल कचरा संग्रह दिखाया गया है।
class TestGC{ @Override // finalize method: called on object once // before garbage collecting it protected void finalize() throws Throwable { System.out.println('Garbage collector called'); System.out.println('Object garbage collected : ' + this); } } class Main{ public static void main(String args()){ TestGC gc1=new TestGC(); TestGC gc2=new TestGC(); gc1 = null; //nullify gc1 System.gc(); //request for GC to run gc2 = null; //nullify gc2 Runtime.getRuntime().gc(); //request for GC to run } }
उत्पादन
उपरोक्त कार्यक्रम में, हमने एक टेस्ट टेस्टजीसी बनाया है। इस वर्ग में, हमने अंतिम रूप () विधि को ओवरराइड कर दिया है। फिर मुख्य वर्ग में, हम TestGC वर्ग के दो ऑब्जेक्ट बनाते हैं। सबसे पहले, हम एक ऑब्जेक्ट को शून्य करते हैं और कचरा कलेक्टर से अनुरोध करने के लिए System.gc () को कॉल करते हैं।
इसके बाद, हम गारबेज कलेक्टर से अनुरोध करने के लिए दूसरी वस्तु और कॉल विधि Runtime.getRuntime.gc () को शून्य करते हैं। आउटपुट अंतिम विधि आउटपुट को दो बार दिखाता है जिससे यह संकेत मिलता है कि कचरा कलेक्टर दो बार चला।
ध्यान दें: हालांकि हमें यह आउटपुट मिला है, लेकिन यह गारंटी नहीं है कि हर बार हमें एक ही आउटपुट मिलेगा। यह पूरी तरह से जेवीएम पर निर्भर करता है।
जावा में कचरा संग्रहण कैसे काम करता है?
इस खंड में, हम देखेंगे कि जावा में कचरा संग्रह कैसे काम करता है।
कचरा संग्रहण के दौरान, गारबेज कलेक्टर हीप मेमोरी को देखता है और फिर अप्राप्य वस्तुओं को 'चिह्नित' करता है। तब यह उन्हें नष्ट कर देता है।
लेकिन समस्या तब पैदा होती है जब वस्तुओं की संख्या बढ़ जाती है। जैसे-जैसे वस्तुएँ बढ़ती जाती हैं, वैसे-वैसे अनुपयोगी वस्तुओं की तलाश में कचरा संग्रहण में लगने वाला समय भी बढ़ता जाता है। हालाँकि, यह बहुत अधिक प्रभावित नहीं करता है क्योंकि अधिकांश वस्तुओं का जीवनकाल कम होता है।
ऊपर का व्यवहार कहा जाता है 'पीढ़ीगत कचरा संग्रह' और JVM प्रदर्शन को बेहतर बनाने वाला है। इस दृष्टिकोण में, पूरे हीप स्थान को विभाजित किया जाता है - यंग जनरेशन, ओल्ड या टेनर्ड जेनरेशन और परमानेंट जेनरेशन।
# 1) युवा पीढ़ी हीप स्पेस: इस अंतरिक्ष में सभी नई वस्तुओं का निर्माण होता है। एक बार अंतरिक्ष भरा होने के बाद, माइनर जीसी जगह लेता है जिसमें सभी मृत वस्तुएं नष्ट हो जाती हैं। मामूली जीसी प्रक्रिया तेज और तेज है क्योंकि अधिकांश वस्तुएं मृत हैं। युवा पीढ़ी को जीवित रखने वाली वस्तुओं को पुरानी पीढ़ियों तक ले जाया जाता है।
# 2) पुरानी पीढ़ी का ढेर स्थान: यह पीढ़ी उन वस्तुओं को संग्रहीत करती है जो लंबे समय तक जीवित रहती हैं। जब युवा पीढ़ी के लिए निर्धारित थ्रेशोल्ड की उम्र पूरी हो जाती है, तो वस्तु पुरानी पीढ़ी में चली जाती है। जब पुरानी पीढ़ी का स्थान भर जाता है, तो एक मेजर जीसी किया जाता है।
मेजर जीसी धीमा है क्योंकि यहां शामिल वस्तुएं जीवित वस्तुएं हैं। कभी-कभी पूरे हीप स्थान में युवा, साथ ही पुरानी पीढ़ियों को भी शामिल किया जाता है। इसे 'पूर्ण जीसी' कहा जाता है।
# 3) स्थायी पीढ़ी जावा 7 तक एक परमानेंट जेनरेशन (पर्म जनरल) हुआ करता था। जेवीएम द्वारा परमिट जनरल आयोजित मेटाडेटा का उपयोग किया गया था। JVM ने इस मेटाडेटा का उपयोग अनुप्रयोग में प्रयुक्त वर्गों और विधियों का वर्णन करने के लिए किया। पर्म जनरल को जावा 8 में हटा दिया गया था।
जावा 8 गारबेज कलेक्शन: पर्म जेन एंड मेटस्पेस
हमने पहले ही परम जनरल स्पेस के बारे में उल्लेख किया है जो जावा 7 तक मौजूद था। हालांकि, अब जावा 8 में, जेवीएम 'मेटास्पेस' नामक देशी मेमोरी का उपयोग करके क्लास मेटाडेटा का प्रतिनिधित्व करता है।
मेटासैपेस के अलावा, एक नया झंडा है जिसे 'मैक्समेटेसैसेसाइज़' कहा जाता है जो क्लास मेटाडेटा के लिए उपयोग की जाने वाली मेमोरी को सीमित करता है। यदि MaxMetaspaceSize के लिए कोई मान निर्दिष्ट नहीं किया गया है, तो Metaspace अनुप्रयोग की मांग के अनुसार रनटाइम पर इसका आकार बदलता है।
जब क्लास मेटाडेटा स्पेस मैक्समेट्सस्पेस पर पहुँचता है, तो मेटासैपेस जीसी ट्रिगर हो जाता है। जब मेटासैपेस जीसी अत्यधिक होता है, तो यह कक्षाओं, क्लास लोडर आदि की मेमोरी लीक के साथ-साथ अपर्याप्त आकार का संकेत देता है।
कचरा संग्रह एल्गोरिदम जावा में
विभिन्न तरीके हैं जिसमें कचरा संग्रह किया जाता है। इस खंड में, हम जावा में कचरा संग्रह के लिए चार ऐसे तरीके या एल्गोरिदम प्रस्तुत करेंगे।
सीरियल जीसी
सीरियल जीसी सबसे सरल जीसी एल्गोरिदम है। यह मुख्य रूप से छोटे ढेर के आकार और एकल-थ्रेडेड सिस्टम पर काम करता है। काम करते समय, सीरियल जीसी सभी अनुप्रयोगों को जमा देता है।
सीरियल जीसी को चालू करने के लिए, हम निम्नलिखित जेवीएम विकल्प का उपयोग कर सकते हैं।
कैसे शुरुआती के लिए एक कंप्यूटर प्रोग्राम करने के लिए
java –xx:+UseSerialGC –jar Application.java
उपरोक्त कमांड कमांड लाइन में दी जा सकती है। यहां Application.java एक फाइल है जिसके लिए सीरियल GC को सक्षम करना है।
थ्रूपुट / समानांतर जीसी
समानांतर GC एल्गोरिथ्म JDK 8 में डिफ़ॉल्ट एक है। यह एल्गोरिथ्म ढेर स्थान और संघनन को स्कैन करने के लिए कई थ्रेड का उपयोग करता है। यह एल्गोरिथ्म ज्यादातर उन अनुप्रयोगों के लिए उपयुक्त है जो थ्रेड पॉज़ को संभाल सकते हैं और सीपीयू ओवरहेड को अनुकूलित कर सकते हैं।
समानांतर GC का एक नुकसान यह है कि मामूली या पूर्ण GC निष्पादित करते समय, एल्गोरिथ्म एप्लिकेशन थ्रेड्स को रोक देता है।
सीएमएस कलेक्टर
CMS का मतलब है ' समवर्ती मार्क स्वीप ”। यह एल्गोरिथ्म कई का उपयोग करता है समवर्ती ढेर को स्कैन करने के लिए धागे ( निशान ) अप्रयुक्त वस्तुओं की पहचान करने के लिए और रीसायकल ( झाड़ू लगा दो ) उन्हें। CMS कलेक्टर में एक स्टॉप-द-वर्ल्ड (STW) है।
कलेक्टर इस मोड में दो परिदृश्यों में जाता है:
- जब पुरानी पीढ़ी से संबंधित वस्तुओं को स्थिर चर या थ्रेड एंट्री पॉइंट से पहुँचा जा सकता है। तो यह मोड प्रारंभिक रूट चिह्नों के प्रारंभ के दौरान है।
- जब एल्गोरिथ्म समवर्ती रूप से चल रहा होता है, तो एप्लिकेशन राज्य को बदल देता है और कलेक्टर को वापस जाने के लिए मजबूर करता है ताकि यह सुनिश्चित हो सके कि सही ऑब्जेक्ट चिह्नित हैं।
CMS कलेक्टर हालांकि 'पदोन्नति विफलताओं' से पीड़ित हो सकता है। तो एक प्रचार विफलता क्या है? यदि युवा पीढ़ी के स्थान से वस्तुओं को पुरानी पीढ़ी में ले जाया जाता है, और कलेक्टर ने पुरानी पीढ़ी के ढेर स्थान में इन वस्तुओं के लिए पर्याप्त स्थान नहीं बनाया है, तो एक प्रचार विफलता होगी।
प्रचार विफलता को रोकने के लिए, हम कलेक्टर को अधिक पृष्ठभूमि धागे प्रदान कर सकते हैं या पुरानी पीढ़ी को अधिक ढेर आकार प्रदान कर सकते हैं।
जी 1 कलेक्टर
G1 कलेक्टर “कचरा-पहला” कलेक्टर है। इसे 4GB से अधिक के आकार के लिए डिज़ाइन किया गया है। ढेर के आकार के आधार पर, यह 1 एमबी से 32 एमबी तक के आकार के क्षेत्रों में हीप आकार को विभाजित करता है।
G1 संग्रहकर्ता पूरे ढेर में वस्तुओं की आजीविका के आधार पर वस्तुओं को चिह्नित करता है। इस अंकन चरण के बाद, जी 1 खाली क्षेत्रों के बारे में पता है। इस प्रकार यह इन क्षेत्रों से पहुंच योग्य वस्तुओं को इकट्ठा करता है, जिससे बड़ी मात्रा में स्थान खाली हो जाता है। इसलिए इसे गारबेज-फर्स्ट नाम दिया गया क्योंकि यह पहले कचरा इकट्ठा करने वाले क्षेत्रों को इकट्ठा करता है।
यह निर्दिष्ट-ठहराव समय लक्ष्य के आधार पर एकत्र करने के लिए क्षेत्रों की संख्या का चयन करके एक ठहराव भविष्यवाणी मॉडल का उपयोग करके उपयोगकर्ता-परिभाषित ठहराव समय लक्ष्य को भी पूरा करता है।
कचरा संग्रहण का लाभ
- कचरा संग्रह जावा में मेमोरी प्रबंधन को कुशल बनाता है क्योंकि यह प्रोग्रामर के हस्तक्षेप के बिना ढेर की मेमोरी से अपरिचित वस्तुओं को हटा देता है।
- जैसा कि कचरा संग्रह स्वचालित है और जेवीएम का एक हिस्सा है, प्रोग्रामर से मेमोरी या विनाशकारी वस्तुओं को पुनः प्राप्त करने के लिए किसी अतिरिक्त प्रयास की आवश्यकता नहीं है।
- प्रोग्रामर को मेमोरी को डी-आवंटित करने और C / C ++ में किए गए ऑब्जेक्ट को हटाने के लिए कोई विशिष्ट कोड लिखने की आवश्यकता नहीं है।
बार बार पूछे जाने वाले प्रश्न
Q # 1) गारबेज कलेक्टर की क्या भूमिका है?
उत्तर: जावा में, कचरा कलेक्टर स्मृति प्रबंधन में मुख्य पार्टी है और अप्राप्य वस्तुओं को इकट्ठा करने और स्मृति को पुनः प्राप्त करने का काम सौंपा जाता है।
Q # 2) कचरा संग्रहण से आपका क्या अभिप्राय है?
उत्तर: कचरा संग्रह वह तकनीक है जिसके द्वारा मेमोरी को अप्रयुक्त मेमोरी को पुनः प्राप्त करके स्वचालित रूप से प्रबंधित किया जाता है। यह जावा जैसी प्रोग्रामिंग भाषाओं में मौजूद एक विशेषता है, जिसके कारण प्रोग्रामर को अप्रयुक्त वस्तुओं पर नज़र रखने और उन्हें नष्ट करने की आवश्यकता नहीं है। यह कचरा संग्रह का उपयोग करके स्वचालित रूप से किया जाता है।
क्यू # 3) जावा में कचरा संग्रहण के लिए कौन जिम्मेदार है?
उत्तर: जावा के मेमोरी प्रबंधन में कचरा संग्रहण की जिम्मेदारी है।
क्यू # 4) हम जावा में कचरा संग्रहण कैसे रोक सकते हैं?
उत्तर: जैसा कि कचरा संग्रहकर्ता चर / वस्तुओं की स्मृति को पुनः प्राप्त नहीं करता है, जो जीवित हैं, कचरा संग्रह को रोकने का सबसे अच्छा तरीका है कि पूरे कार्यक्रम में चर / वस्तुओं का उपयोग करते रहें।
क्यू # 5) आप यह कैसे सुनिश्चित कर सकते हैं कि एक वस्तु कचरा एकत्र किया गया है?
उत्तर: एक ऑब्जेक्ट कचरा संग्रह के लिए योग्य है जब यह पहुंच से बाहर है यानी जब कोई संदर्भ वस्तु का संदर्भ नहीं दे रहा हो। हालाँकि हम जब भी चाहें कूड़ा उठाने वाले को चलने के लिए मजबूर नहीं कर सकते, हम हमेशा System.gc () का उपयोग करके इसे चलाने का अनुरोध कर सकते हैं।
निष्कर्ष
जावा में कचरा संग्रह जिसे हमने इस ट्यूटोरियल में चर्चा की है, वह स्वचालित है और प्रोग्रामर को प्रोग्राम में आवंटित वस्तुओं या चर को हटाने के बारे में खुद को चिंता करने की आवश्यकता नहीं है।
जावा में स्वचालित कचरा संग्रह भाषा की सबसे महत्वपूर्ण विशेषता है और यह जावा में मेमोरी प्रबंधन का एक हिस्सा है।
हालांकि कचरा संग्रह JVM द्वारा किया जाता है और प्रोग्रामर की पहुंच से बाहर है, हम हमेशा सिस्टम (सिस्टम) और रनटाइम क्लास का उपयोग करके गारबेज कलेक्टर से अनुरोध कर सकते हैं।
इस ट्यूटोरियल में, हमने अंतिम रूप देने की प्रक्रिया पर चर्चा की है जो वस्तुओं को कचरा कलेक्टर द्वारा नष्ट किए जाने से पहले किया जाता है। हमने जावा में कचरा संग्रह की प्रक्रिया पर भी चर्चा की है। अंत में, हमने कचरा संग्राहक द्वारा उपयोग किए जाने वाले विभिन्न एल्गोरिदम पर चर्चा की है।
यह जावा में कचरा कलेक्टर पर हमारी चर्चा को पूरा करता है।
=> यहाँ सरल जावा प्रशिक्षण श्रृंखला देखें।
अनुशंसित पाठ
- जावा बेसिक्स: जावा सिंटैक्स, जावा क्लास और कोर जावा कॉन्सेप्ट
- जावा के लिए क्या उपयोग किया जाता है: 12 वास्तविक विश्व जावा अनुप्रयोग
- जावा स्ट्रिंग ट्यूटोरियल | उदाहरण के साथ जावा स्ट्रिंग के तरीके
- जावा ट्यूटोरियल फॉर बिगिनर्स: 100+ हैंड्स-ऑन जावा वीडियो ट्यूटोरियल
- जावा कंपोनेंट्स: जावा प्लेटफॉर्म, जेडीके, जेआरई, और जावा वर्चुअल मशीन
- जावा परिनियोजन: जावा जार फाइल का निर्माण और निष्पादन
- जावा वर्चुअल मशीन: जावा एप्लीकेशन चलाने में JVM कैसे मदद करता है
- उदाहरणों के साथ जावा परावर्तन ट्यूटोरियल