मैं जावा में नया हूं और जावा में कचरा संग्रहकर्ता के बारे में उलझन में हूं। यह वास्तव में क्या करता है और कब आता है। कृपया जावा में कचरा कलेक्टर के कुछ गुणों का वर्णन करें।
मैं जावा में नया हूं और जावा में कचरा संग्रहकर्ता के बारे में उलझन में हूं। यह वास्तव में क्या करता है और कब आता है। कृपया जावा में कचरा कलेक्टर के कुछ गुणों का वर्णन करें।
जवाबों:
कचरा कलेक्टर यह व्यवस्था पर चलता है जावा वर्चुअल मशीन जो वस्तुओं जो अब एक जावा अनुप्रयोग उपयोग नहीं किया जा रहा है से छुटकारा मिलता है। यह स्वचालित स्मृति प्रबंधन का एक रूप है ।
जब एक विशिष्ट जावा एप्लिकेशन चल रहा होता है, तो यह नई वस्तुओं का निर्माण कर रहा है, जैसे कि Stringएस और Fileएस, लेकिन एक निश्चित समय के बाद, उन वस्तुओं का उपयोग नहीं किया जाता है। उदाहरण के लिए, निम्नलिखित कोड पर एक नज़र डालें:
for (File f : files) {
String s = f.getName();
}
उपरोक्त कोड में, लूप के String sप्रत्येक पुनरावृत्ति पर बनाया जा रहा है for। इसका मतलब यह है कि प्रत्येक पुनरावृत्ति में, किसी Stringवस्तु को बनाने के लिए थोड़ी मेमोरी आवंटित की जा रही है ।
कोड पर वापस जाने पर, हम देख सकते हैं कि एक बार एक पुनरावृत्ति निष्पादित होने के बाद, अगले पुनरावृत्ति Stringमें, पिछले पुनरावृत्ति में बनाई गई वस्तु का अब उपयोग नहीं किया जा रहा है - उस वस्तु को अब "कचरा" माना जाता है।
आखिरकार, हमें बहुत अधिक कचरा मिलना शुरू हो जाएगा, और मेमोरी का उपयोग उन वस्तुओं के लिए किया जाएगा जो अब उपयोग नहीं किए जा रहे हैं। यदि यह जारी रहता है, तो अंततः जावा वर्चुअल मशीन नई वस्तुओं को बनाने के लिए अंतरिक्ष से बाहर चलेगी।
यहीं पर कूड़ा बीनने वाले कदम रखते हैं।
कचरा संग्रहकर्ता उन वस्तुओं की तलाश करेगा जिनका अब उपयोग नहीं किया जा रहा है, और उनसे छुटकारा मिल जाता है, स्मृति को मुक्त कर देता है ताकि अन्य नई वस्तुएं स्मृति के उस टुकड़े का उपयोग कर सकें।
जावा में, स्मृति प्रबंधन कचरा कलेक्टर द्वारा ध्यान रखा जाता है, लेकिन जैसे C अन्य भाषाओं में, एक की जरूरत है जैसे अपने स्वयं के कार्यों का उपयोग करने पर स्मृति प्रबंधन प्रदर्शन करने के लिए mallocऔरfree । मेमोरी प्रबंधन उन चीजों में से एक है, जो गलतियों को करना आसान है, जो कि मेमोरी लीक कहलाती हैं - ऐसी जगहें, जहां मेमोरी का पुनः उपयोग नहीं किया जाता है, जब वे उपयोग में नहीं होती हैं।
कचरा संग्रहण जैसी स्वचालित मेमोरी प्रबंधन योजनाएं इसे बनाती हैं ताकि प्रोग्रामर को मेमोरी प्रबंधन के मुद्दों के बारे में इतना परेशान न होना पड़े, इसलिए वह उन अनुप्रयोगों को विकसित करने पर अधिक ध्यान केंद्रित कर सकता है जिन्हें उन्हें विकसित करने की आवश्यकता है।
यह उन ऑब्जेक्ट्स के लिए आवंटित मेमोरी को मुक्त करता है जो प्रोग्राम द्वारा किसी भी अधिक उपयोग नहीं किए जा रहे हैं - इसलिए "कचरा" नाम। उदाहरण के लिए:
public static Object otherMethod(Object obj) {
return new Object();
}
public static void main(String[] args) {
Object myObj = new Object();
myObj = otherMethod(myObj);
// ... more code ...
}
मुझे पता है कि यह बेहद विरोधाभासी है, लेकिन यहां आपके द्वारा कॉल किए जाने के बाद otherMethod()मूल Objectबनाया अनुपलब्ध है - और यह "कचरा" है जो कचरा एकत्र करता है।
जावा में जीसी स्वचालित रूप से चलता है, लेकिन आप इसे स्पष्ट रूप से कॉल कर सकते हैं System.gc()और एक प्रमुख कचरा संग्रह को मजबूर करने का प्रयास कर सकते हैं । जैसा कि पास्कल थिवेंट बताते हैं, आपको वास्तव में ऐसा नहीं करना चाहिए और यह अच्छे से अधिक नुकसान कर सकता है ( इस प्रश्न को देखें )।
अधिक के लिए, कचरा संग्रह और ट्यूनिंग कचरा संग्रह पर Oracle से विकिपीडिया प्रविष्टि देखें )
System.gc()जीसी को चलाने के लिए मजबूर नहीं करता है।
myObjकॉल करने से पहले नष्ट करने के लिए पूरी तरह से मान्य otherMethodहै, क्योंकि myObjअब उस बिंदु पर पहुंच योग्य नहीं है।
System.gc(), जीसी होने के पूरे बिंदु को ऐसा नहीं करना है।
एक वस्तु कचरा संग्रह या जीसी के लिए पात्र हो जाती है अगर यह किसी भी जीवित धागे से या किसी भी स्थिर संदर्भ से नहीं पहुंच पाती है।
दूसरे शब्दों में, आप कह सकते हैं कि यदि कोई वस्तु कचरा संग्रह के लिए योग्य हो जाती है यदि उसके सभी संदर्भ शून्य हैं। चक्रीय निर्भरता को संदर्भ के रूप में नहीं गिना जाता है इसलिए यदि ऑब्जेक्ट ए में ऑब्जेक्ट बी का संदर्भ है और ऑब्जेक्ट बी में ऑब्जेक्ट ए का संदर्भ है और उनके पास कोई अन्य लाइव संदर्भ नहीं है तो ऑब्जेक्ट ए और बी दोनों ही कचरा संग्रह के लिए पात्र होंगे।
कचरा संग्रहण के लिए ढेर जनरेशन -
जावा ऑब्जेक्ट को बनाया जाता है Heapऔर Heapजावा में कचरा संग्रह के लिए तीन भागों या पीढ़ियों में विभाजित किया जाता है, इन्हें यंग (नई) पीढ़ी, तपती (पुरानी) पीढ़ी और ढेर का परमिट क्षेत्र कहा जाता है।
नई पीढ़ी को ईडन स्पेस, सर्वाइवर 1 और सर्वाइवर 2 स्पेस के रूप में जाना जाता है। जब पहली बार बनाई गई कोई वस्तु ईडन स्पेस के अंदर नई पीढ़ी में बनाई जाती है और बाद में मामूली कचरा संग्रह के बाद यदि कोई वस्तु बच जाती है तो उसके अवशेष 1 में चले जाते हैं और फिर प्रमुख कचरा संग्रह से पहले 2 बचे उस वस्तु को पुरानी या दसवीं पीढ़ी में ले जाया जाता है ।
जावा हीप की अनुमति स्थान वह जगह है जहां जेवीएम मेटाडेटा को कक्षाओं और विधियों, स्ट्रिंग पूल और कक्षा स्तर के विवरण के बारे में संग्रहीत करता है।
अधिक के लिए यहाँ देखें: कचरा संग्रह
आप JVM को गारबेज कलेक्शन को चलाने के लिए बाध्य नहीं कर सकते, हालाँकि आप एक अनुरोध System.gc()या Runtime.gc()विधि का उपयोग कर सकते हैं ।
public static void gc() {
Runtime.getRuntime().gc();
}
public native void gc(); // note native method
मार्क और स्वीप एल्गोरिदम -
यह कचरा संग्रह द्वारा उपयोग किए जाने वाले सबसे लोकप्रिय एल्गोरिदम में से एक है। किसी भी कचरा संग्रह एल्गोरिथ्म को 2 बुनियादी संचालन करना होगा। एक, यह सभी पहुंच से बाहर की वस्तुओं का पता लगाने में सक्षम होना चाहिए और दूसरा, यह कचरा वस्तुओं द्वारा उपयोग किए गए ढेर स्थान को पुनः प्राप्त करना चाहिए और कार्यक्रम को फिर से स्थान उपलब्ध कराना चाहिए।
उपरोक्त संचालन मार्क और स्वीप एल्गोरिथ्म द्वारा दो चरणों में किए जाते हैं:
अधिक विवरण के लिए यहां पढ़ें - मार्क और स्वीप एल्गोरिथ्म
कचरा कलेक्टर जेआरई का हिस्सा है जो यह सुनिश्चित करता है कि जिस वस्तु को संदर्भित नहीं किया गया है उसे मेमोरी से मुक्त कर दिया जाएगा।
यह आमतौर पर तब चलता है जब आप ऐप को मेमोरी से रन आउट करते हैं। AFAIK यह एक ग्राफ रखता है जो वस्तुओं के बीच लिंक का प्रतिनिधित्व करता है और अलग-थलग वस्तुओं को मुक्त किया जा सकता है।
पीढ़ियों में समूहीकृत वर्तमान वस्तुओं के प्रदर्शन को बचाने के लिए, हर बार जीसी एक ऑब्जेक्ट को स्कैन करता है और पाता है कि यह अभी भी 1 द्वारा संवर्धित इसकी पीढ़ी की गिनती (कुछ अधिकतम अधिकतम मूल्य, 3 या 4 मुझे लगता है) को संदर्भित करता है, और नई पीढ़ी को पहले स्कैन किया जाता है (स्मृति में सबसे छोटी वस्तु शायद इसकी अब आवश्यकता नहीं है) इसलिए सभी वस्तुओं को हर बार जीसी चलाने के लिए स्कैन नहीं किया जाता है। अधिक जानकारी के लिए इसे
पढ़ें ।
कचरा संग्रहकर्ता आपके कंप्यूटर को अनंत स्मृति वाले कंप्यूटर का अनुकरण करने की अनुमति देता है। बाकी सिर्फ तंत्र है।
यह पता लगाने के द्वारा किया जाता है कि मेमोरी के चंक्स अब आपके कोड से सुलभ नहीं हैं, और उन विखंडू को मुफ्त स्टोर में वापस कर रहे हैं।
संपादित करें: हां, लिंक सी # के लिए है, लेकिन सी # और जावा इस संबंध में समान हैं।
बहुत से लोग सोचते हैं कि कचरा एकत्र करना मृत वस्तुओं को इकट्ठा करता है और उनकी रक्षा करता है।
वास्तव में, जावा कचरा संग्रह विपरीत कार्य कर रहा है! लाइव ऑब्जेक्ट्स को ट्रैक किया जाता है और बाकी सब कुछ कचरा निर्दिष्ट किया जाता है।
जब कोई ऑब्जेक्ट अब उपयोग नहीं किया जाता है, तो कचरा कलेक्टर अंतर्निहित मेमोरी को पुनः प्राप्त करता है और इसे भविष्य के ऑब्जेक्ट आवंटन के लिए पुन: उपयोग करता है। इसका मतलब है कि कोई स्पष्ट विलोपन नहीं है और ऑपरेटिंग सिस्टम पर कोई मेमोरी वापस नहीं दी गई है। यह निर्धारित करने के लिए कि कौन सी वस्तुएँ अब उपयोग में नहीं हैं, JVM रुक-रुक कर चलता है, जिसे बहुत उपयुक्त रूप से मार्क-एंड-स्वीप एल्गोरिथ्म कहा जाता है।
अधिक विस्तार से जानकारी के लिए इसे देखें: http://javabook.compuware.com/content/memory/how-garbage-collection-works.aspx
इसे सबसे सरल शब्दों में रखने के लिए, जिसे एक गैर-प्रोग्रामर भी समझ सकता है, जब कोई प्रोग्राम उस डेटा को प्रोसेस करता है, तो उस डेटा के लिए इंटरमीडिएट डेटा और स्टोरेज स्पेस (वेरिएबल्स, एरेज़, कुछ ऑब्जेक्ट मेटाडेटा आदि) बनाता है।
जब ये ऑब्जेक्ट फ़ंक्शंस या एक निश्चित आकार से अधिक तक पहुंच जाते हैं, तो उन्हें एक केंद्रीय ढेर से आवंटित किया जाता है। फिर जब उन्हें लंबे समय की जरूरत नहीं होती है, तो उन्हें साफ करने की आवश्यकता होती है।
यह कैसे काम करता है इसके बारे में ऑनलाइन कुछ बहुत अच्छे लेख हैं, इसलिए मैं अभी बहुत मूल परिभाषा को कवर करूंगा।
जीसी मूल रूप से फ़ंक्शन है जो यह सफाई करता है। ऐसा करने के लिए तालिका प्रविष्टियों को साफ़ किया जाता है जो किसी भी सक्रिय ऑब्जेक्ट्स द्वारा संदर्भित नहीं होते हैं, प्रभावी ढंग से ऑब्जेक्ट्स को हटा रहे हैं, कॉपी और मेमोरी को कॉम्पैक्ट करते हैं। यह इससे थोड़ा अधिक जटिल है, लेकिन आपको यह विचार मिलता है।
बड़ी समस्या यह है कि कुछ हिस्सों में इस प्रक्रिया में अक्सर पूरे जावा वीएम को अस्थायी रूप से जगह लेने के लिए रोकना पड़ता है, साथ ही यह पूरी प्रक्रिया बहुत प्रोसेसर और मेमोरी बैंडविड्थ गहन होने की आवश्यकता होती है। GCs के रूप में विभिन्न विकल्प और हर एक के लिए ट्यूनिंग विकल्प पूरे GC प्रक्रिया के साथ इन विभिन्न मुद्दों को संतुलित करने के लिए डिज़ाइन किए गए हैं।
जावा (और अन्य भाषाओं / प्लेटफार्मों में) के रूप में कचरा संग्रह जावा रन-टाइम पर्यावरण (JRE) के लिए एक तरह से जावा ऑब्जेक्ट से मेमोरी का पुन: उपयोग करने का एक तरीका है जिसकी अब आवश्यकता नहीं है। सरलीकृत रूप से, जब JRE शुरू में शुरू होता है, तो यह एक निश्चित मात्रा में मेमोरी के लिए ऑपरेटिंग सिस्टम (O / S) पूछता है। जैसा कि JRE आपके एप्लिकेशन को चलाता है, यह उस मेमोरी का उपयोग करता है। जब आपके एप्लिकेशन को उस मेमोरी का उपयोग किया जाता है, तो JRE का "कचरा कलेक्टर" साथ आता है और उस मेमोरी को आपके मौजूदा एप्लिकेशन के विभिन्न हिस्सों द्वारा उपयोग के लिए याद करता है। JRE का "कचरा कलेक्टर" एक पृष्ठभूमि कार्य है जो हमेशा चलता रहता है और सिस्टम को बेकार में चलाने के लिए कई बार चुनने की कोशिश करता है।
एक वास्तविक विश्व सादृश्य होगा कचरा पुरुष जो आपके घर में आते हैं और आपके रिसाइकिल योग्य कचरे को उठाते हैं ... अंततः, इसका अन्य तरीकों से अपने और / या अन्य लोगों द्वारा पुन: उपयोग किया जाता है।
कचरा संग्रहकर्ता को संदर्भ गणना प्रबंधक के रूप में देखा जा सकता है। यदि कोई ऑब्जेक्ट बनाया जाता है और उसका संदर्भ एक चर में संग्रहीत किया जाता है, तो इसकी संदर्भ गणना एक से बढ़ जाती है। निष्पादन के दौरान यदि वह चर NULL के साथ सौंपा गया है। उस वस्तु के लिए संदर्भ गणना में कमी की गई है। इसलिए वस्तु के लिए वर्तमान संदर्भ गणना 0. है। अब जब गारबेज कलेक्टर निष्पादित किया जाता है, तो यह संदर्भ संख्या 0. के साथ वस्तुओं की जांच करता है और इसके लिए आवंटित संसाधनों को मुक्त करता है।
कचरा संग्रहण आमंत्रण को कचरा संग्रहण नीतियों द्वारा नियंत्रित किया जाता है।
आप यहां कुछ डेटा प्राप्त कर सकते हैं। http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html
कचरा संग्राहक jvm का एक घटक है।
इसका उपयोग कचरा इकट्ठा करने के लिए किया जाता है जब कभी सीपीयू मुक्त हो जाता है।
यहां कचरा का मतलब अप्रयुक्त वस्तुओं से है जो मुख्य कार्यक्रम की पृष्ठभूमि में चलता है
मुख्य कार्यक्रम की स्थिति की निगरानी करना।
स्वचालित कचरा संग्रह हीप मेमोरी को देखने की प्रक्रिया है, यह पहचान कर कि कौन सी वस्तुएं उपयोग में हैं और कौन सी नहीं हैं और अप्रयुक्त वस्तुओं को हटा रही हैं। उपयोग की वस्तु, या संदर्भित वस्तु में, का अर्थ है कि आपके कार्यक्रम का कुछ हिस्सा अभी भी उस वस्तु के लिए एक संकेतक रखता है। एक अप्रयुक्त वस्तु, या अप्रतिबंधित वस्तु, अब आपके कार्यक्रम के किसी भी हिस्से से संदर्भित नहीं है। तो एक अप्रतिबंधित वस्तु द्वारा उपयोग की जाने वाली मेमोरी को पुनः प्राप्त किया जा सकता है।
C जैसी प्रोग्रामिंग भाषा में, मेमोरी आवंटित करना और डील करना एक मैन्युअल प्रक्रिया है। जावा में, मेमोरी कलेक्टर से निपटने की प्रक्रिया को कचरा कलेक्टर द्वारा स्वचालित रूप से नियंत्रित किया जाता है। कृपया बेहतर समझ के लिए लिंक की जाँच करें। http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
कचरा संग्रह उन वस्तुओं को हटाकर स्मृति को स्वचालित रूप से मुक्त करने की प्रक्रिया को संदर्भित करता है जो अब आपके प्रोग्राम में उपलब्ध नहीं हैं। ढेर एक मेमोरी है जिसे मुफ्त स्टोर के रूप में जाना जाता है, आपके जावा एप्लिकेशन को आवंटित अप्रयुक्त मेमोरी के एक बड़े पूल का प्रतिनिधित्व करता है।
कचरा संग्रह के मूल सिद्धांत एक कार्यक्रम में डेटा ऑब्जेक्ट को खोजना है जो भविष्य में एक्सेस नहीं किया जा सकता है, और उन वस्तुओं के लिए उपयोग किए गए संसाधनों को पुनः प्राप्त करने के लिए। https://en.wikipedia.org/wiki/Garbage_collection_%28computer_science%29
लाभ
1) बग से बचाता है, जो तब होता है जब स्मृति का एक टुकड़ा मुक्त हो जाता है, जबकि अभी भी इसके लिए संकेत होते हैं, और उन बिंदुओं में से एक को छोड़ दिया जाता है। https://en.wikipedia.org/wiki/Dangling_pointer
2) डबल फ्री बग, जो तब होता है जब प्रोग्राम मेमोरी के एक क्षेत्र को मुक्त करने की कोशिश करता है जिसे पहले ही मुक्त कर दिया गया है, और शायद पहले से ही फिर से आवंटित किया गया है।
3) कुछ प्रकार की मेमोरी लीक से बचाता है, जिसमें एक प्रोग्राम उन वस्तुओं द्वारा कब्जा की गई मेमोरी को मुक्त करने में विफल हो जाता है जो कि पहुंच से बाहर हो गए हैं, जिससे मेमोरी थकावट हो सकती है।
नुकसान
1) अतिरिक्त संसाधन, प्रदर्शन प्रभाव, कार्यक्रम निष्पादन में संभावित स्टॉल, और मैनुअल संसाधन प्रबंधन के साथ असंगति का उपभोग करना। कचरा संग्रह यह तय करने में कंप्यूटिंग संसाधनों की खपत करता है कि कौन सी मेमोरी को मुक्त करना है, भले ही प्रोग्रामर को यह जानकारी पहले से पता हो।
2) वह क्षण जब कचरा वास्तव में एकत्र किया जाता है, अप्रत्याशित हो सकता है, जिसके परिणामस्वरूप पूरे सत्र में स्टॉल (शिफ्ट / मुक्त मेमोरी को रोक दिया जाता है)। अप्रत्याशित स्टॉल वास्तविक समय के वातावरण में, लेनदेन प्रसंस्करण में, या इंटरैक्टिव कार्यक्रमों में अस्वीकार्य हो सकते हैं।
Oracle ट्यूटोरियल http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
कचरा संग्रह वह प्रक्रिया है जो यह पहचानती है कि कौन सी वस्तुएं उपयोग में हैं और कौन सी नहीं हैं और अप्रयुक्त वस्तुओं को हटा रही हैं।
C, C ++ जैसी प्रोग्रामिंग भाषाओं में, मेमोरी को आवंटित करना और मुक्त करना एक मैन्युअल प्रक्रिया है।
int * array = new int[size];
processArray(array); //do some work.
delete array; //Free memory
प्रक्रिया के पहले चरण को अंकन कहा जाता है। यह वह जगह है जहां कचरा संग्रहकर्ता यह पहचानता है कि मेमोरी के कौन से टुकड़े उपयोग में हैं और कौन से नहीं हैं।
चरण 2 ए। सामान्य विलोपन संदर्भित वस्तुओं और पॉइंटर्स को खाली स्थान पर छोड़ने से अपरिचित वस्तुओं को हटा देता है।
प्रदर्शन में सुधार करने के लिए, हम बिना संदर्भित ऑब्जेक्ट को हटाना चाहते हैं और शेष संदर्भित ऑब्जेक्ट को भी कॉम्पैक्ट करते हैं। हम संदर्भित वस्तुओं को एक साथ रखना चाहते हैं, इसलिए नई मेमोरी को आवंटित करना तेज होगा।
जैसा कि पहले कहा गया है, एक JVM में सभी वस्तुओं को चिह्नित और कॉम्पैक्ट करने के लिए अक्षम है। जैसा कि अधिक से अधिक वस्तुओं को आवंटित किया जाता है, वस्तुओं की सूची बढ़ती है और लंबे समय तक और लंबे समय तक कचरा संग्रह के लिए अग्रणी होती है।
इस ट्यूटोरियल को पढ़ना जारी रखें, और आपको पता चल जाएगा कि GC यह चुनौती कैसे लेता है।
संक्षेप में, वहाँ ढेर के तीन क्षेत्रों, कर रहे हैं YoungGeneration लघु जीवन वस्तुओं के लिए, OldGeneration लंबी अवधि वस्तुओं के लिए, और PermanentGeneration वस्तुओं है कि आवेदन जीवन के दौरान रहते हैं, उदाहरण के लिए, कक्षाएं, पुस्तकालयों के लिए के लिए।
जैसा कि ऑब्जेक्ट्स को नए ऑपरेटर द्वारा गतिशील रूप से आवंटित किया जाता है , आप पूछ सकते हैं कि ये ऑब्जेक्ट कैसे नष्ट हो जाते हैं और मेमोरी को कैसे मुक्त किया जाता है। सी ++ जैसी अन्य भाषाओं में, आपको डिलीट ऑपरेटर द्वारा गतिशील रूप से आवंटित वस्तुओं को मैन्युअल रूप से मुक्त करने की आवश्यकता है। जावा में एक अलग दृष्टिकोण है; यह स्वचालित रूप से डीलक्लोकेशन को संभालता है। तकनीक को कचरा संग्रह के रूप में जाना जाता है ।
यह इस तरह काम करता है: जब किसी ऑब्जेक्ट का कोई संदर्भ नहीं होता है, तो यह माना जाता है कि इस ऑब्जेक्ट की अब आवश्यकता नहीं है और आप ऑब्जेक्ट द्वारा कब्जा की गई मेमोरी को पुनः प्राप्त कर सकते हैं। C ++ की तरह वस्तुओं को स्पष्ट रूप से नष्ट करना आवश्यक नहीं है। कचरा निष्पादन कार्यक्रम निष्पादन के दौरान छिटपुट रूप से होता है; यह केवल इसलिए नहीं होता है क्योंकि एक या अधिक ऑब्जेक्ट हैं जो अब उपयोग नहीं किए जाते हैं। इसके अलावा, कई जावा रनटाइम कार्यान्वयन में कचरा संग्रहण के लिए अलग-अलग दृष्टिकोण हैं, लेकिन अधिकांश प्रोग्रामर को प्रोग्राम लिखते समय इसके बारे में चिंता करने की आवश्यकता नहीं है।
स्वचालित कचरा संग्रह एक ऐसी प्रक्रिया है, जहां JVM से छुटकारा मिलता है या चल रहे कार्यक्रम के लिए स्थान खाली करने के लिए कुछ डेटा बिंदुओं को याद रखता है। मेमोरी को सबसे पहले मेमोरी को ढेर करने के लिए भेजा जाता है, यहीं पर कचरा संग्रहकर्ता (GC) अपना काम करता है, फिर उसे समाप्त करने या रखने का निर्णय लिया जाता है। जावा मानता है कि प्रोग्रामर पर हमेशा भरोसा नहीं किया जा सकता है, इसलिए यह उन वस्तुओं को समाप्त कर देता है जो यह सोचते हैं कि इसकी आवश्यकता नहीं है।