कचरा संग्रह केवल ढेर क्यों करता है?


28

मूल रूप से, मैंने अब तक सीखा है कि कचरा संग्रह हमेशा के लिए किसी भी डेटा संरचना को मिटा देता है जो वर्तमान में इंगित नहीं किया जा रहा है। लेकिन यह केवल ऐसी स्थितियों के लिए ढेर की जांच करता है।

यह डेटा अनुभाग (ग्लोबल्स, कॉन्स्टेंट, आदि) या स्टैक के रूप में अच्छी तरह से जांच क्यों नहीं करता है? यह ढेर के बारे में क्या है कि यह केवल एक चीज है जिसे हम कचरा एकत्र करना चाहते हैं?


21
"स्वीप द हीप" "व्हैक द स्टैक" से अधिक सुरक्षित है ... :-)
ब्रायन नोब्लुक

जवाबों:


62

कचरा संग्रहकर्ता स्टैक को स्कैन करता है - यह देखने के लिए कि स्टैक पर मौजूद चीजों द्वारा वर्तमान में किस चीज़ का उपयोग किया जा रहा है (इंगित किया गया है)।

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

(सिस्टम हैं, जैसे कि स्मॉलटाक, जहां स्टैक फ्रेम प्रथम श्रेणी की वस्तुएं हैं जो ढेर में संग्रहीत हैं और कचरा अन्य सभी वस्तुओं को इकट्ठा किया जाता है। लेकिन इन दिनों यह लोकप्रिय दृष्टिकोण नहीं है। जावा के जेवीएम और माइक्रोसॉफ्ट के सीएलआर हार्डवेयर स्टैक और सन्निहित मेमोरी का उपयोग करते हैं। ।)


7
+1 स्टैक हमेशा पूरी तरह से उपलब्ध होता है इसलिए इसे स्वीप करने का कोई मतलब नहीं है
शाफ़्ट सनकी

2
+1 ने आपको धन्यवाद दिया, सही उत्तर देने के लिए 4 पोस्ट लिए। मुझे नहीं पता कि आपको स्टैक पर सब कुछ क्यों कहना पड़ा "माना जाता है" उपयोग में होने के लिए, यह इसका उपयोग कम से कम एक मजबूत भावना के रूप में है क्योंकि अभी भी उपयोग में आने वाली वस्तुएं उपयोग में हैं - लेकिन यह एक वास्तविक नाइटपिक है बहुत अच्छा जवाब।
Psr

@psr का मतलब है कि स्टैक पर सब कुछ बहुत ही आसानी से उपलब्ध है और विधि के वापस आने तक इसे इकट्ठा करने की कोई आवश्यकता नहीं है लेकिन यह (RAII) पहले से ही स्पष्ट रूप से प्रबंधित है
शाफ़्ट फ्रीक

@ratchetfreak - मुझे पता है। और मेरा मतलब सिर्फ इतना ही था कि "माना" शब्द की आवश्यकता नहीं है, इसके बिना एक मजबूत बयान देना ठीक है।
psr

5
@psr: मैं असहमत हूं। " माना उपयोग में है" दोनों ढेर और ढेर के लिए और अधिक सही, बहुत महत्वपूर्ण कारणों के लिए है। आप जो चाहते हैं उसे छोड़ देना है जो फिर से उपयोग नहीं किया जाएगा; आप जो करते हैं वह यह है कि आप जो चीज नहीं पढ़ सकते हैं उसे छोड़ देते हैं । आपके पास अच्छी तरह से उपलब्ध डेटा हो सकता है जिसकी आपको कभी आवश्यकता नहीं होगी; जब यह डेटा बढ़ता है, तो आपके पास मेमोरी लीक होती है (हाँ, वे GC'ed भाषाओं में भी संभव हैं, जबकि कई लोग सोचते हैं)। और कोई यह तर्क दे सकता है कि स्टैक लीक भी होता है, पूंछ-पुनरावृत्ति कार्यक्रम के बिना चलने वाले पूंछ-पुनरावर्ती कार्यक्रमों में गैर-स्टैक फ़्रेमों का सबसे आम उदाहरण है (जैसे जेवीएम पर)।
ब्लिसोरब्लेड

19

अपने सवाल को घुमाओ। वास्तविक प्रेरक प्रश्न यह है कि हम किन परिस्थितियों में कचरा संग्रहण की लागत से बच सकते हैं?

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

हम इन लागतों से कैसे बच सकते हैं?

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

लेकिन अगर हमने छेद की समस्या को हल कर लिया है तो हमने कचरा संग्रहण समस्या को भी हल कर दिया है । क्या आपके पास उस भंडारण में कुछ है जो अभी भी जीवित है? हाँ। क्या यह सब कुछ लंबे समय तक रहने से पहले आवंटित किया गया था? हाँ - यह धारणा है कि हमने छिद्रों की संभावना को कैसे समाप्त किया। इसलिए आपको केवल इतना कहना है कि "सबसे हालिया आवंटन जीवित है?" और आप जानते हैं कि उस भंडारण में सब कुछ जीवित है।

क्या हमारे पास भंडारण आवंटन का एक सेट है जहां हम जानते हैं कि हर बाद का आवंटन पिछले आवंटन की तुलना में कम है? हाँ! विधियों के सक्रियण फ़्रेम हमेशा विपरीत क्रम में नष्ट हो जाते हैं जो उन्हें बनाया गया था क्योंकि वे हमेशा सक्रियण की तुलना में कम रहते थे जो उन्हें बनाया था।

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

यही कारण है कि हमारे पास पहले स्थान पर स्टैक पर अस्थायी पूल है: क्योंकि यह मेमोरी मेमोरी पेनल्टी को लागू किए बिना विधि सक्रियण को लागू करने का एक आसान तरीका है।

(निश्चित रूप से सक्रियण फ़्रेम पर संदर्भों द्वारा संदर्भित मेमोरी को इकट्ठा करने वाले कचरे की लागत अभी भी है।)

अब एक नियंत्रण प्रवाह प्रणाली पर विचार करें जिसमें सक्रियण फ्रेम एक पूर्वानुमेय क्रम में नष्ट नहीं होते हैं । यदि अल्पकालिक सक्रियण दीर्घजीवी सक्रियता को जन्म दे सकता है तो क्या होगा? जैसा कि आप कल्पना कर सकते हैं, इस दुनिया में आप सक्रियण को इकट्ठा करने की आवश्यकता को दूर करने के लिए स्टैक का उपयोग नहीं कर सकते हैं। सक्रियण के सेट में फिर से छेद हो सकते हैं।

C # 2.0 में यह सुविधा है yield return। एक विधि जो पैदावार वापसी करती है, उसे बाद के समय में फिर से सक्रिय किया जाएगा - अगली बार जब MoveNext कहा जाता है - और जब ऐसा होता है तो पूर्वानुमान नहीं होता है। इसलिए सूचना जो सामान्य रूप से इटरेटर ब्लॉक के सक्रियण फ्रेम के लिए स्टैक पर होती है, उसे बजाय ढेर पर संग्रहीत किया जाता है, जहां यह कचरा इकट्ठा किया जाता है जब एन्यूमरेटर एकत्र किया जाता है।

इसी तरह, C # और VB के अगले संस्करणों में आने वाला "एसिंक्स / वेट" फीचर आपको उन तरीकों को बनाने की अनुमति देगा जिनकी क्रियाशीलता "उपज" और विधि की कार्रवाई के दौरान अच्छी तरह से परिभाषित बिंदुओं पर "फिर से शुरू" होती है। चूंकि सक्रियण फ़्रेम अब अनुमानित रूप से बनाए और नष्ट नहीं किए जाते हैं, इसलिए स्टैक में संग्रहीत सभी जानकारी को ढेर में संग्रहीत करना होगा।

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


13

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

क्लास डिफेक्ट, कॉन्स्टेंट और अन्य स्टैटिक डेटा स्ट्रक्चर्स द्वारा खपत की जा रही मेमोरी अनियंत्रित रूप से बढ़ने की संभावना नहीं है। चूँकि उस वर्ग की किसी अज्ञात संख्या के रन टाइम के अनुसार मेमोरी में केवल एक ही क्लास की परिभाषा है, इसलिए यह समझ में आता है कि इस प्रकार की संरचना मेमोरी के उपयोग के लिए कोई खतरा नहीं है।


5
लेकिन ढेर "उदाहरण डेटा" का स्थान नहीं है। वे ढेर पर भी हो सकते हैं।
svick

@svick भाषा पर निर्भर करता है, बिल्कुल। जावा केवल ढेर-आवंटित वस्तुओं का समर्थन करता है, और वेला काफी स्पष्ट रूप से ढेर-आवंटित (वर्ग) और स्टैक-आवंटित (संरचना) के बीच अंतर करता है।
शराबी

1
@fluffy: वे बहुत सीमित भाषाएं हैं, आप यह नहीं मान सकते कि यह सामान्य है क्योंकि कोई भी भाषा पहले से तैयार नहीं थी।
मैथ्यू एम।

@MatthieuM। वह मेरी बात की तरह था।
शराबी

@fluffy: तो ढेर में कक्षाएं क्यों आवंटित की जाती हैं, जबकि स्टैक में संरचनाएं आवंटित की जाती हैं?
डार्क टेम्पलर

10

यह इस कारण को ध्यान में रखने योग्य है कि हमारे पास कचरा संग्रह क्यों है: क्योंकि कभी-कभी यह याद रखना मुश्किल होता है कि मेमोरी कब डील करना है। आपको वास्तव में केवल ढेर के साथ यह समस्या है। स्टैक पर आवंटित डेटा को अंततः डील किया जाएगा, इसलिए वहाँ वास्तव में कचरा संग्रह करने की कोई आवश्यकता नहीं है। डेटा अनुभाग में चीजें आमतौर पर कार्यक्रम के जीवनकाल के लिए आवंटित की जाती हैं।


1
न केवल इसे 'अंततः' से निपटाया जाएगा, बल्कि इसे सही समय पर निपटाया जाएगा।
बोरिस यानकोव

3
  1. उन लोगों का आकार अनुमानित है (स्टैक को छोड़कर निरंतर, और स्टैक आमतौर पर कुछ एमबी तक सीमित है) और आमतौर पर बहुत कम (कम से कम सैकड़ों एमबी बड़े अनुप्रयोगों को आवंटित किया जा सकता है)।

  2. डायनामिक रूप से आवंटित वस्तुओं में आमतौर पर एक छोटी समय सीमा होती है जिसमें वे पहुंच में होते हैं। उसके बाद, कोई तरीका नहीं है कि उन्हें फिर से संदर्भित किया जा सके। कंट्रास्ट कि डेटा सेक्शन, ग्लोबल वैरिएबल्स और इस तरह की प्रविष्टियों के साथ: अक्सर, कोड का एक टुकड़ा होता है जो उन्हें सीधे संदर्भित करता है (विचार करें const char *foo() { return "foo"; })। आम तौर पर, कोड में बदलाव नहीं होता है, इसलिए रहने के लिए संदर्भ होता है और प्रत्येक बार फ़ंक्शन को लागू करने के लिए एक और संदर्भ बनाया जाएगा (जो किसी भी समय हो सकता है जहां तक ​​कंप्यूटर जानता है - जब तक आप हॉल्टिंग समस्या को हल नहीं करते हैं, तब तक )। इस प्रकार आप उस मेमोरी को अधिकतर मुक्त नहीं कर सकते , क्योंकि यह हमेशा उपलब्ध होगी।

  3. कई कचरा एकत्र की गई भाषा में, सब कुछ जो कार्यक्रम चलाया जा रहा है, ढेर-आवंटित है। पायथन में, बस कोई डेटा अनुभाग नहीं है और कोई स्टैक-आवंटित मान नहीं है (ऐसे संदर्भ हैं जो स्थानीय चर हैं, और कॉल स्टैक है, लेकिन न तो intसी में एक ही अर्थ में एक मूल्य है)। हर वस्तु ढेर पर है।


"पायथन में, बस कोई डेटा अनुभाग नहीं है"। यह कड़ाई से सच नहीं बोल रहा है। कोई भी, सही और गलत डेटा खंड में आवंटित नहीं किया जाता है क्योंकि मैं इसे समझता हूं: stackoverflow.com/questions/7681786/how-is-hashnone-calculated
जेसन बेकर

@JasonBaker: दिलचस्प खोज! हालांकि इसका कोई प्रभाव नहीं है। यह एक कार्यान्वयन विवरण है और निर्मित वस्तुओं तक सीमित है। यह उल्लेख नहीं है कि उन वस्तुओं को कार्यक्रम के जीवनकाल में कभी भी निपटाए जाने की उम्मीद नहीं है, वे भी नहीं हैं, और आकार में भी छोटे हैं (प्रत्येक 32 बाइट से कम, मुझे लगता है)।

एरिक लिपर्ट के रूप में @delnan यह इंगित करने का शौक रखते हैं, ज्यादातर भाषाओं के लिए ढेर और ढेर के लिए अलग-अलग मेमोरी क्षेत्रों का अस्तित्व एक कार्यान्वयन विवरण है। आप एक स्टैक का उपयोग किए बिना अधिकांश भाषाओं को लागू कर सकते हैं (हालांकि प्रदर्शन तब भी हो सकता है जब आप करते हैं) और फिर भी उनके विनिर्देशों के अनुरूप हो
जूल्स

2

जैसा कि कई अन्य उत्तरदाताओं ने कहा है, स्टैक रूट सेट का हिस्सा है, इसलिए इसे संदर्भों के लिए स्कैन किया जाता है, लेकिन "एकत्रित" नहीं, प्रति से।

मैं बस कुछ टिप्पणियों का जवाब देना चाहता हूं जो कि ढेर पर कचरा डालने से कोई फर्क नहीं पड़ता है; यह करता है, क्योंकि यह ढेर पर अधिक कचरा पैदा कर सकता है जिसे पहुंच योग्य माना जाता है। ईमानदार वीएम और कंपाइलर लेखक या तो स्टैक से मृत भागों को बाहर निकाल देते हैं या अन्यथा खाली कर देते हैं। IIRC, कुछ VMs में टेबल मैपिंग पीसी रेंज होती है, जो स्टैक-स्लॉट-लाईन बिटमैप्स और अन्य बस स्लॉट्स को खाली कर देती है। मुझे नहीं पता कि वर्तमान में कौन सी तकनीक पसंद की जाती है।

इस विशेष विचार का वर्णन करने के लिए उपयोग किया जाने वाला एक शब्द सुरक्षित-के-लिए है


जानना दिलचस्प होगा। पहले सोचा था कि रिक्त स्थान को शून्य करना सबसे यथार्थवादी है। अपवर्जित क्षेत्रों के एक पेड़ का पता लगाने में अच्छी तरह से नल के माध्यम से स्कैनिंग की तुलना में अधिक समय लग सकता है। जाहिर है स्टैक को कॉम्पैक्ट करने का कोई भी प्रयास जोखिम से भरा है! उस काम को करना एक मन-झुकने / त्रुटि-प्रवण प्रक्रिया की तरह लगता है।
ब्रायन नोब्लुच

@ ब्रायन, वास्तव में, इसके बारे में कुछ और सोचकर, टाइप किए गए वीएम के लिए आपको वैसे भी कुछ चाहिए, इसलिए आप यह निर्धारित कर सकते हैं कि कौन से स्लॉट पूर्णांक, फ्लोट्स आदि के विपरीत संदर्भ हैं, साथ ही, स्टैक को कॉम्पैक्ट करने के संबंध में, "CONS चाहिए।" हेनरी बेकर द्वारा इसके तर्क नहीं "।
रयान कल्पेपर

स्लॉट प्रकारों का निर्धारण करना और यह सत्यापित करना कि वे उचित रूप से उपयोग किए जा रहे हैं और आमतौर पर संवैधानिक रूप से किया जाता है, या तो संकलन समय (विश्वसनीय बायटेकोड का उपयोग करने वाले वीएम के लिए) या लोड समय (जहां बायटेकोड एक अविश्वसनीय स्रोत, जैसे जावा से आता है)।
जूल्स

1

मुझे कुछ मूलभूत गलतफहमियों की ओर इशारा करते हैं जो आप और कई अन्य गलत हैं:

"कचरा संग्रह केवल ढेर क्यों करता है?" यह दूसरा रास्ता है। केवल सबसे सरल, सबसे रूढ़िवादी और धीमी गति से कचरा इकट्ठा करने वाले लोग ढेर को स्वीप करते हैं। इसलिए वे इतने धीमे हैं।

फास्ट कचरा कलेक्टर केवल स्टैक को स्वीप करते हैं (और वैकल्पिक रूप से कुछ अन्य जड़ें, जैसे एफएफआई पॉइंटर्स के लिए कुछ ग्लोबल्स, और लाइव पॉइंटर्स के लिए रजिस्टर), और केवल स्टैक ऑब्जेक्ट्स द्वारा पहुंच योग्य पॉइंटर्स को कॉपी करते हैं। बाकी को दूर फेंक दिया जाता है (यानी अनदेखा किया जाता है), ढेर पर स्कैनिंग नहीं।

चूंकि ढेर स्टैक (ओं) से लगभग 1000x बड़ा है, ऐसे स्टैक-स्कैनिंग जीसी आमतौर पर बहुत तेज होते हैं। ~ 15ms बनाम 250ms सामान्य आकार के ढेर पर। चूंकि यह एक स्थान से दूसरे स्थान पर वस्तुओं को कॉपी (स्थानांतरित) कर रहा है, इसलिए इसे ज्यादातर अर्ध-अंतरिक्ष प्रतिलिपि कलेक्टर कहा जाता है, इसे 2x मेमोरी की आवश्यकता होती है और इसलिए बहुत छोटे उपकरणों पर उपयोग करने योग्य नहीं है, जिसमें बहुत अधिक मेमोरी वाले फोन पसंद नहीं होते हैं। यह कॉम्पैक्टिंग है, इसलिए यह साधारण चिह्न और स्वीप हीप स्कैनर के विपरीत बहुत अधिक कैश फ्रेंडली है।

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

मार्क एंड स्वीप को लागू करने के लिए तुच्छ है, लेकिन इसका उपयोग वास्तविक कार्यक्रमों में नहीं किया जाना चाहिए, और विशेष रूप से मानक कलेक्टर के रूप में सिखाया नहीं जाना चाहिए। ऐसे फास्ट स्टैक-स्कैनिंग कॉपी कलेक्टर के सबसे प्रसिद्ध को चेनी टू-फिंगर कलेक्टर कहा जाता है ।


यह सवाल अधिक लगता है कि विशिष्ट कचरा संग्रह एल्गोरिदम के बजाय स्मृति के किन हिस्सों में कचरा एकत्र किया जाता है। विशेष रूप से अंतिम वाक्य का अर्थ है कि ओपी "स्वीप" का उपयोग कचरा संग्रहण को लागू करने के लिए एक विशिष्ट तंत्र के बजाय "कचरा एकत्र करने" के लिए एक सामान्य पर्याय के रूप में कर रहा है। यह देखते हुए, आपका जवाब यह कहकर सामने आता है कि केवल सबसे सरल कचरा संग्रहकर्ता कचरा ढेर इकट्ठा करते हैं, और तेजी से कचरा इकट्ठा करने वाले कचरा इकट्ठा करने के बजाय ढेर और स्थिर मेमोरी इकट्ठा करते हैं, जिससे ढेर बढ़ता है और तब तक बढ़ता है जब तक कि यह स्मृति से बाहर नहीं निकल जाता।
8bittree

नहीं, प्रश्न बहुत विशिष्ट और चतुर था। जवाब ऐसा नहीं है। स्लो मार्क एंड स्वीप जीसी के दो चरण होते हैं, स्टैक पर जड़ों को स्कैन करने वाले मार्क स्टेप और स्वीप फेज को ढेर स्कैन करता है। तेजी से नकल जीसी के पास केवल एक चरण है, स्टैक को स्कैन करना। आसान है। चूंकि स्पष्ट रूप से उचित कचरा उठाने वालों के बारे में यहां कोई नहीं जानता, इसलिए सवाल का जवाब देने की जरूरत है। आपकी व्याख्या बेतहाशा बंद है।
रुबर्न

0

स्टैक पर क्या आवंटित किया गया है? स्थानीय चर और वापसी पते (सी में)। जब कोई फ़ंक्शन वापस आता है, तो उसके स्थानीय चर को छोड़ दिया जाता है। स्टैक को स्वीप करने के लिए यह नेक्रेटिक, हानिकारक भी नहीं है।

कई गतिशील भाषाएं, और जावा या सी # भी एक सिस्टम प्रोग्रामिंग भाषा में कार्यान्वित की जाती हैं, अक्सर सी में। आप कह सकते हैं कि जावा को सी फ़ंक्शन के साथ लागू किया गया है और सी स्थानीय चर का उपयोग करता है और इसलिए जावा के कचरा कलेक्टर को स्टैक को स्वीप करने की आवश्यकता नहीं है।

एक दिलचस्प अपवाद है: चिकन स्कीम का कचरा संग्रहकर्ता स्टैक को स्वीप करता है (एक तरह से), क्योंकि इसके कार्यान्वयन से स्टैक को कचरा संग्रहण पहली पीढ़ी के स्थान के रूप में उपयोग किया जाता है: चिकन योजना डिज़ाइन विकिपीडिया देखें

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.