दिलचस्प पोस्ट
सी # – माउस कर्सर छवि कैप्चरिंग कैसे जावास्क्रिप्ट के साथ GetElementById के बजाय ElementByClass प्राप्त करने के लिए? डॉट (।) ऑपरेटर और -> सी ++ में अंतर क्या है? क्लाइंट साइड पर सूची के लिए एमवीसी कस्टम वैलिडेशन सी # तिथि समय "YYYYMMDDHHMMSS" प्रारूप में जब मॉडल पहले से मौजूद है, तो `रेल को स्कैफोल्ड बनाने 'को चलाने के लिए कैसे? पार्स स्टिंग टू फ्लोट या इंट JFrame आइकन कैसे परिवर्तित करें वसंत संपत्ति प्लेसहोल्डर को हल नहीं किया जा सका जावा: आधार और एक्सटेंशन में फ़ाइल नाम को विभाजित करना AngularJs "नियंत्रक के रूप में" वाक्यविन्यास – स्पष्टीकरण? तीर ऑपरेटर क्या करता है, '-' ', जावा में करते हो? उपकरण पर SQL डेटाबेस को डिबग करना अंतर के भीतर अंतर और आंतरिक एचटीएमएल आर: एकाधिक डेटा निर्यात करने के लिए आसान तरीका एकाधिक एक्सेल कार्यपत्रकों के लिए फ्रेम?

कैसे जावा कूड़ा संग्रह परिपत्र संदर्भ के साथ काम करता है?

मेरी समझ से, जावा में कचरा संग्रह कुछ ऑब्जेक्ट को साफ करता है, अगर कुछ भी उस ऑब्जेक्ट के लिए 'इशारा' नहीं है।

मेरा सवाल है, क्या होगा अगर हमारे पास ऐसा कुछ है:

class Node { public object value; public Node next; public Node(object o, Node n) { value = 0; next = n;} } //...some code { Node a = new Node("a", null), b = new Node("b", a), c = new Node("c", b); a.next = c; } //end of scope //...other code 

a , b , और c कचरा इकट्ठा किया जाना चाहिए, लेकिन इन सभी को अन्य वस्तुओं द्वारा संदर्भित किया जा रहा है।

इस के साथ जावा कचरा संग्रह कैसे सौदा करता है? (या यह केवल एक स्मृति नाली है?)

वेब के समाधान से एकत्रित समाधान "कैसे जावा कूड़ा संग्रह परिपत्र संदर्भ के साथ काम करता है?"

जावा की जीसी वस्तुओं को "कचरा" मानती है, यदि वे किसी कचरा संग्रह जड़ से शुरू होने वाली श्रृंखला के माध्यम से नहीं पहुंच पा रहे हैं, तो इन वस्तुओं को एकत्र किया जाएगा। हालांकि वस्तुएं एक चक्र बनाने के लिए एक-दूसरे को इंगित कर सकती हैं, फिर भी अगर वे जड़ से काट रहे हैं तो वे अभी भी कूड़े हैं

परिशिष्ट ए में अपरिवर्तनीय ऑब्जेक्ट्स पर अनुभाग देखें: जावा में कचरा संग्रह के बारे में सच्चाई प्लेटफार्म प्रदर्शन: धूर्त विवरण के लिए रणनीतियां और रणनीतियां ।

हाँ जावा कचरा कलेक्टर परिपत्र-संदर्भ संभालता है!

 How? 

कचरा संग्रह जड़ों (जीसी जड़ें) नामक विशेष वस्तुएं हैं। ये हमेशा पहुंचने योग्य होते हैं और ऐसा कोई भी वस्तु है जो उन्हें अपने रूट पर है।

एक साधारण जावा अनुप्रयोग में निम्न जीसी जड़ों हैं:

  1. मुख्य विधि में स्थानीय चर
  2. मुख्य थ्रेड
  3. मुख्य वर्ग के स्थिर चर

यहां छवि विवरण दर्ज करें

यह निर्धारित करने के लिए कि अब कौन सा ऑब्जेक्ट्स उपयोग में नहीं हैं, JVM अंततः एक मार्क-एंड-स्वीप एल्गोरिथ्म कहलाता है। यह निम्नानुसार काम करता है

  1. एल्गोरिदम सभी ऑब्जेक्ट संदर्भों को सीधा करता है, जीसी जड़ों से शुरू होता है, और हर वस्तु को जीवित रूप में पाया जाता है।
  2. सभी मेकअप मेमोरी जिन्हें चिह्नित ऑब्जेक्ट्स पर कब्जा नहीं किया गया है, उन्हें पुनः प्राप्त किया गया है। यह नि: शुल्क के रूप में चिह्नित है, अनिवार्य रूप से अप्रयुक्त वस्तुओं से मुक्त है।

इसलिए अगर कोई ऑब्जेक्ट जीसी जड़ों से नहीं पहुंचा जा सकता है (भले ही यह स्वयं संदर्भित है या चक्रीय-संदर्भित है), इसे कचरा संग्रहण के अधीन किया जाएगा।

पाठ्यक्रम कभी-कभी यह स्मृति रिसाव हो सकता है अगर प्रोग्रामर किसी वस्तु को हटाना भूल जाता है।

यहां छवि विवरण दर्ज करें

स्रोत: जावा मेमोरी प्रबंधन

एक कचरा कलेक्टर कुछ "मूल" स्थानों से सेट होता है जो हमेशा "पहुंचने योग्य" जैसे सीपीयू रजिस्टरों, स्टैक, और ग्लोबल वैरिएबल मानते हैं। यह उन क्षेत्रों में किसी भी संकेत प्राप्त करने के द्वारा काम करता है, और उन सभी बिंदुओं को पुनः प्राप्त कर रहा है जो वे इंगित करते हैं। एक बार यह सब मिल गया है, बाकी सब कचरा है

ज़ाहिर है, गति की खातिर ज्यादातर बदलाव हैं उदाहरण के लिए, अधिकांश आधुनिक कचरा लेनेवाले "पीढ़ीदार" होते हैं, जिसका अर्थ है कि वे वस्तुओं को पीढ़ियों में विभाजित करते हैं, और एक वस्तु के रूप में बड़े हो जाते हैं, कचरा कलेक्टर समय के बीच लंबे और लंबे समय तक जाता है, यह यह समझने की कोशिश करता है कि वह वस्तु अभी भी मान्य है या नहीं – यह सिर्फ मानना ​​शुरू होता है कि अगर यह लंबे समय तक रहता है, तो संभावना बहुत अच्छी है कि यह अब तक जीना जारी रखेगी।

बहरहाल, मूल विचार एक समान ही है: यह सभी चीजों के कुछ रूट सेट से शुरू करने के आधार पर होता है जो इसे दी गई है, अभी भी उपयोग किया जा सकता है, और फिर सभी संकेतों का पीछा करते हुए पता लगाने के लिए और क्या उपयोग में हो सकता है।

एक तरफ दिलचस्प: लोगों को अक्सर कचरा कलेक्टर के इस भाग के बीच समानता की डिग्री और दूरस्थ प्रक्रिया कॉल जैसी चीज़ों के लिए वस्तुओं को संगृहीत करने के लिए कोड द्वारा आश्चर्यचकित किया जाता है। प्रत्येक मामले में, आप कुछ रूट ऑब्जेक्ट्स से शुरू कर रहे हैं, और उन अन्य ऑब्जेक्ट्स को ढूंढने के लिए पॉइंटर्स का पीछा करते हुए देखें …

तुम सही हो। आपके द्वारा वर्णित कचरा संग्रहण का विशिष्ट रूप " संदर्भ गणना " कहा जाता है जिस तरह से यह काम करता है (सरलता से, कम से कम, संदर्भ गणना की सबसे आधुनिक कार्यान्वयन वास्तव में काफी भिन्न रूप से लागू किया जाता है) सरलतम मामले में, ऐसा दिखता है:

  • जब भी किसी ऑब्जेक्ट का कोई संदर्भ जोड़ा जाता है (जैसे यह किसी वैरिएबल या फ़ील्ड को सौंपा जाता है, विधि से पारित किया जाता है, और इसी तरह), इसकी संदर्भ गणना 1 से बढ़ जाती है
  • जब भी किसी ऑब्जेक्ट का संदर्भ निकाल दिया जाता है (विधि रिटर्न, वेरिएबल क्षेत्र से बाहर निकलता है, फ़ील्ड को एक अलग ऑब्जेक्ट के लिए फिर से सौंपा जाता है या उस ऑब्जेक्ट में फ़ील्ड को कचरा एकत्र किया जाता है), संदर्भ संख्या 1 से कम हो जाती है
  • जैसे ही संदर्भ संख्या हिट 0 के रूप में, वस्तु का कोई और संदर्भ नहीं है, जिसका अर्थ है कि कोई भी इसका उपयोग नहीं कर सकता है, इसलिए यह कूड़ा है और इसे एकत्र किया जा सकता है

और यह साधारण रणनीति आपके द्वारा लिखी गई समस्या है: यदि कोई संदर्भ बी और बी संदर्भ A, तो उनके संदर्भ संख्या दोनों 1 से कम कभी नहीं हो सकते, जिसका अर्थ है कि उन्हें कभी भी एकत्र नहीं किया जाएगा।

इस समस्या से निपटने के चार तरीके हैं:

  1. अनदेखी करो इसे। यदि आपके पास पर्याप्त मेमोरी है, तो आपके चक्र छोटे और विलक्षण हैं और आपका रनटाइम कम है, हो सकता है कि आप केवल चक्रों को इकट्ठा न करें। शेल स्क्रिप्ट interpreter के बारे में सोचें: शेल स्क्रिप्ट आमतौर पर केवल कुछ सेकंड के लिए चलती है और बहुत मेमोरी आवंटित नहीं करती।
  2. अपने कन्वेयर कलेक्टर के साथ कचरा कलेक्टर की गिनती को गठबंधन करें, जिसमें चक्र के साथ कोई समस्या नहीं है। CPython ऐसा करता है, उदाहरण के लिए: CPython में मुख्य कचरा कलेक्टर एक संदर्भ गिनती कलेक्टर है, लेकिन समय-समय पर एक ट्रेसिंग कचरा कलेक्टर चक्र एकत्र करने के लिए चलाया जाता है।
  3. चक्र का पता लगाएं दुर्भाग्य से, एक ग्राफ में चक्रों का पता लगाने के बजाय एक महँगा ऑपरेशन होता है। विशेष रूप से, इसके लिए बहुत अधिक एक ही ओवरहेड की आवश्यकता होती है जो एक अनुरेखक कलेक्टर होता, ताकि आप उन में से किसी एक का उपयोग कर सकें।
  4. आप और मैं होगा भोले तरीके से एल्गोरिथ्म को लागू न करें: 1 9 70 के दशक से, कई बहुत दिलचस्प एल्गोरिदम विकसित हुए हैं जो कि एक चतुर तरीके से एक ही ऑपरेशन में चक्र पहचान और संदर्भ गणना को जोड़ते हैं जो कि या तो उनसे काफी सस्ता है दोनों अलग-अलग या एक अनुरेखक कलेक्टर कर रहे हैं

वैसे, एक कचरा कलेक्टर को लागू करने का दूसरा प्रमुख तरीका (और मैंने पहले ही उस पर दो बार संकेत दिया है), ट्रेसिंग है । एक अनुरेखक कलेक्टर पहुंचनीयता की अवधारणा पर आधारित है। आप कुछ रूट सेट के साथ शुरू करते हैं जिसे आप जानते हैं (वैश्विक स्थिरांक, उदाहरण के लिए, या Object क्लास, वर्तमान लेक्सिकल गुंजाइश, वर्तमान स्टैक फ्रेम) और वहां से आप सभी ऑब्जेक्ट्स को ट्रेस करते हैं जो रूट सेट से पहुंच योग्य हैं, तब सभी ऑब्जेक्ट्स जो ऑब्जेक्ट्स से पहुंच योग्य हैं, जो कि रूट सेट से पहुंच योग्य हैं और इतने पर, जब तक आप पारगमन बंद नहीं करते। उस बंद में नहीं है जो सब कुछ कचरा है

चूंकि एक चक्र केवल अपने भीतर ही पहुंच योग्य है, लेकिन रूट सेट से नहीं पहुंच पा रहा है, इसलिए इसे एकत्र किया जाएगा।

जैसा कि आप वर्णन करते हैं, जावा जीसी वास्तव में व्यवहार नहीं करते हैं यह कहना सही है कि वे ऑब्जेक्ट्स के बेस सेट से शुरू करते हैं, जिसे अक्सर "जीसी जर्ड्स" कहा जाता है, और किसी भी ऑब्जेक्ट को इकट्ठा करता है जिसे रूट से नहीं पहुंचा जा सकता है।
जीसी जड़ें इसमें शामिल हैं:

  • स्थैतिक चर
  • स्थानीय चर (सभी लागू 'इस' संदर्भों सहित) वर्तमान में चल रहे थ्रेड के स्टैक में है

इसलिए, आपके मामले में, स्थानीय पद्धति, ए, बी, और सी, आपकी पद्धति के अंत में गुंजाइश से बाहर निकल जाने के बाद, आपके जीनों की कोई और जीसी जड़ें नहीं हैं, जो सीधे या अप्रत्यक्ष रूप से आपके किसी भी तीन नोड्स के संदर्भ में हैं और वे कचरा संग्रहण के लिए पात्र होंगे

यदि आप इसे चाहते हैं तो टोफूबीयर के लिंक में और अधिक विवरण है

यह लेख कचरा कलेक्टर के बारे में गहराई में आता है (अवधारणात्मक रूप से … कई कार्यान्वयन हैं) आपकी पोस्ट के लिए प्रासंगिक हिस्सा "A.3.4 पहुंच योग्य" है

कचरा संग्रह का आमतौर पर मतलब नहीं है "कुछ ऑब्जेक्ट को साफ़ करें IF कुछ भी नहीं है" उस ऑब्जेक्ट की ओर इशारा करते हैं "(यह संदर्भ गिनती है)। कचरा संग्रह का लगभग मतलब वस्तुओं को खोजने का अर्थ है जो कार्यक्रम से नहीं पहुंचा जा सकता है।

इसलिए आपके उदाहरण में, ए, बी और सी के दायरे से बाहर जाने के बाद, वे जीसी द्वारा एकत्र किए जा सकते हैं, क्योंकि आप इन वस्तुओं को अब और नहीं एक्सेस कर सकते हैं।

बिल ने सीधे आपके प्रश्न का उत्तर दिया जैसा कि अम्नोन ने कहा, आपकी कचरा संग्रह की परिभाषा सिर्फ संदर्भ गिनती है। मैं सिर्फ यह जोड़ना चाहता था कि मार्क और स्वीप और कॉपी संग्रह जैसे बहुत सरल एल्गोरिदम आसानी से परिपत्र संदर्भ संभालते हैं। तो, इसके बारे में जादू नहीं है!