जावा में कचरा संग्रहकर्ता क्या है?


103

मैं जावा में नया हूं और जावा में कचरा संग्रहकर्ता के बारे में उलझन में हूं। यह वास्तव में क्या करता है और कब आता है। कृपया जावा में कचरा कलेक्टर के कुछ गुणों का वर्णन करें।



10
कभी-कभी एक अच्छी पुस्तक के अध्याय को एक प्रश्न के उत्तर से जटिल विषय को समझने की अपेक्षा करना बेहतर होता है।
इयान रिंगरोज 15

4
@ यह एक समान प्रश्न है, लेकिन डुप्लिकेट नहीं है। और वह प्रश्न reeks होमवर्क की।
NullUserException 15

जवाबों:


119

कचरा कलेक्टर यह व्यवस्था पर चलता है जावा वर्चुअल मशीन जो वस्तुओं जो अब एक जावा अनुप्रयोग उपयोग नहीं किया जा रहा है से छुटकारा मिलता है। यह स्वचालित स्मृति प्रबंधन का एक रूप है ।

जब एक विशिष्ट जावा एप्लिकेशन चल रहा होता है, तो यह नई वस्तुओं का निर्माण कर रहा है, जैसे कि Stringएस और Fileएस, लेकिन एक निश्चित समय के बाद, उन वस्तुओं का उपयोग नहीं किया जाता है। उदाहरण के लिए, निम्नलिखित कोड पर एक नज़र डालें:

for (File f : files) {
    String s = f.getName();
}

उपरोक्त कोड में, लूप के String sप्रत्येक पुनरावृत्ति पर बनाया जा रहा है for। इसका मतलब यह है कि प्रत्येक पुनरावृत्ति में, किसी Stringवस्तु को बनाने के लिए थोड़ी मेमोरी आवंटित की जा रही है ।

कोड पर वापस जाने पर, हम देख सकते हैं कि एक बार एक पुनरावृत्ति निष्पादित होने के बाद, अगले पुनरावृत्ति Stringमें, पिछले पुनरावृत्ति में बनाई गई वस्तु का अब उपयोग नहीं किया जा रहा है - उस वस्तु को अब "कचरा" माना जाता है।

आखिरकार, हमें बहुत अधिक कचरा मिलना शुरू हो जाएगा, और मेमोरी का उपयोग उन वस्तुओं के लिए किया जाएगा जो अब उपयोग नहीं किए जा रहे हैं। यदि यह जारी रहता है, तो अंततः जावा वर्चुअल मशीन नई वस्तुओं को बनाने के लिए अंतरिक्ष से बाहर चलेगी।

यहीं पर कूड़ा बीनने वाले कदम रखते हैं।

कचरा संग्रहकर्ता उन वस्तुओं की तलाश करेगा जिनका अब उपयोग नहीं किया जा रहा है, और उनसे छुटकारा मिल जाता है, स्मृति को मुक्त कर देता है ताकि अन्य नई वस्तुएं स्मृति के उस टुकड़े का उपयोग कर सकें।

जावा में, स्मृति प्रबंधन कचरा कलेक्टर द्वारा ध्यान रखा जाता है, लेकिन जैसे C अन्य भाषाओं में, एक की जरूरत है जैसे अपने स्वयं के कार्यों का उपयोग करने पर स्मृति प्रबंधन प्रदर्शन करने के लिए mallocऔरfreeमेमोरी प्रबंधन उन चीजों में से एक है, जो गलतियों को करना आसान है, जो कि मेमोरी लीक कहलाती हैं - ऐसी जगहें, जहां मेमोरी का पुनः उपयोग नहीं किया जाता है, जब वे उपयोग में नहीं होती हैं।

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


क्या यह कहना सही होगा कि कंप्यूटर पर चलने वाले जावा एप्लिकेशन में दो कचरा संग्रहण कार्य होते हैं। जावा वर्चुअल मशीन के साथ एक। और फिर विंडोज चलाने वाली वास्तविक मशीन पर एक? (या कोई अन्य ओएस)
20

नहीं, आमतौर पर जावा एप्लिकेशन केवल तभी चलते हैं यदि JRE मौजूद है। तो, केवल जेवीएम के कचरा संग्रह की कार्यक्षमता की आवश्यकता है! @Lealo
Am_I_Helpful

18

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

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 से विकिपीडिया प्रविष्टि देखें )


1
AFAIK System.gc()जीसी को चलाने के लिए मजबूर नहीं करता है।
इत्तो कारो

1
अच्छे कोड उदाहरण के लिए +1। ध्यान दें कि यह GC को myObjकॉल करने से पहले नष्ट करने के लिए पूरी तरह से मान्य otherMethodहै, क्योंकि myObjअब उस बिंदु पर पहुंच योग्य नहीं है।
बिली ओपल

@ मुझे विश्वास है कि यह विशिष्ट कार्यान्वयन है।
NullUserException

2
मेरा मानना ​​है कि किसी को कॉल नहीं करना चाहिए System.gc(), जीसी होने के पूरे बिंदु को ऐसा नहीं करना है।
पास्कल थिवेंट

भागने के विश्लेषण ( en.wikipedia.org/wiki/Escape_analysis ) के साथ, यह संभव है कि जेवीएम इस उदाहरण में पहले स्थान पर वस्तु को आवंटित न करे। संपूर्ण वस्तु निर्माण (सिद्धांत रूप में) दूर किया जा सकता है। कार्यान्वयन पाठ्यक्रम पर निर्भर करता है।
mikera

15

एक वस्तु कचरा संग्रह या जीसी के लिए पात्र हो जाती है अगर यह किसी भी जीवित धागे से या किसी भी स्थिर संदर्भ से नहीं पहुंच पाती है।

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


कचरा संग्रहण के लिए ढेर जनरेशन -

जावा ऑब्जेक्ट को बनाया जाता है Heapऔर Heapजावा में कचरा संग्रह के लिए तीन भागों या पीढ़ियों में विभाजित किया जाता है, इन्हें यंग (नई) पीढ़ी, तपती (पुरानी) पीढ़ी और ढेर का परमिट क्षेत्र कहा जाता है।

जावा हीप स्पेस नई पीढ़ी को ईडन स्पेस, सर्वाइवर 1 और सर्वाइवर 2 स्पेस के रूप में जाना जाता है। जब पहली बार बनाई गई कोई वस्तु ईडन स्पेस के अंदर नई पीढ़ी में बनाई जाती है और बाद में मामूली कचरा संग्रह के बाद यदि कोई वस्तु बच जाती है तो उसके अवशेष 1 में चले जाते हैं और फिर प्रमुख कचरा संग्रह से पहले 2 बचे उस वस्तु को पुरानी या दसवीं पीढ़ी में ले जाया जाता है ।

जावा हीप की अनुमति स्थान वह जगह है जहां जेवीएम मेटाडेटा को कक्षाओं और विधियों, स्ट्रिंग पूल और कक्षा स्तर के विवरण के बारे में संग्रहीत करता है।

कचरा संग्रहण के लिए ढेर जनरेशन

अधिक के लिए यहाँ देखें: कचरा संग्रह


आप JVM को गारबेज कलेक्शन को चलाने के लिए बाध्य नहीं कर सकते, हालाँकि आप एक अनुरोध System.gc()या Runtime.gc()विधि का उपयोग कर सकते हैं ।

Java.lang.System में

public static void gc() {
    Runtime.getRuntime().gc();  
}

Java.lang.Runtime में

public native void gc();  // note native  method

मार्क और स्वीप एल्गोरिदम -

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

उपरोक्त संचालन मार्क और स्वीप एल्गोरिथ्म द्वारा दो चरणों में किए जाते हैं:

  1. मार्क चरण
  2. स्वीप चरण

अधिक विवरण के लिए यहां पढ़ें - मार्क और स्वीप एल्गोरिथ्म


6

कचरा संग्रहकर्ता का तात्पर्य है कि जिन वस्तुओं को अब प्रोग्राम की आवश्यकता नहीं है वे "कचरा" हैं और उन्हें फेंक दिया जा सकता है।


6

कचरा कलेक्टर जेआरई का हिस्सा है जो यह सुनिश्चित करता है कि जिस वस्तु को संदर्भित नहीं किया गया है उसे मेमोरी से मुक्त कर दिया जाएगा।
यह आमतौर पर तब चलता है जब आप ऐप को मेमोरी से रन आउट करते हैं। AFAIK यह एक ग्राफ रखता है जो वस्तुओं के बीच लिंक का प्रतिनिधित्व करता है और अलग-थलग वस्तुओं को मुक्त किया जा सकता है।
पीढ़ियों में समूहीकृत वर्तमान वस्तुओं के प्रदर्शन को बचाने के लिए, हर बार जीसी एक ऑब्जेक्ट को स्कैन करता है और पाता है कि यह अभी भी 1 द्वारा संवर्धित इसकी पीढ़ी की गिनती (कुछ अधिकतम अधिकतम मूल्य, 3 या 4 मुझे लगता है) को संदर्भित करता है, और नई पीढ़ी को पहले स्कैन किया जाता है (स्मृति में सबसे छोटी वस्तु शायद इसकी अब आवश्यकता नहीं है) इसलिए सभी वस्तुओं को हर बार जीसी चलाने के लिए स्कैन नहीं किया जाता है। अधिक जानकारी के लिए इसे
पढ़ें ।


@quantumSoup क्या आप इस पर विचार कर रहे हैं? मेरा मानना ​​है कि किसी प्रकार का कचरा संग्रह (अधिक महंगा) केवल तभी होता है जब ढेर भर जाता है।
पाब्लो फर्नांडीज

2
@quantumSoup - जो JRE के GC कार्यान्वयन पर निर्भर करता है। कई मामलों में, जीसी लगातार नहीं चलता है। इसके बजाय, यह तब चलता है जब आपका ऐप किसी ऑब्जेक्ट को आवंटित करने में असमर्थ होता है क्योंकि ढेर भरा होता है। हाल के हॉटस्पॉट JVM में एक समानांतर GC शामिल है, लेकिन यह डिफ़ॉल्ट रूप से सक्षम नहीं है।
स्टीफन सी

यह उत्तर तंत्र पर बहुत अधिक ध्यान केंद्रित करता है। सवाल यह था कि "कचरा उठाने वाला क्या है", "कचरा
उठाने वाला

@quantum: आपके -1 को बेअसर कर दिया, क्योंकि: सीखना, अर्थात, यह पृष्ठ किस लिए है, है ना? सीखने के लिए आपको गलतियाँ करने की आवश्यकता है। गलतियाँ करने से लोग सीखते नहीं। आशा है, आप उस बिंदु में सहमत हो सकते हैं। और शायद आपने यहां गलती की।
erikbwork

1
@erikb: उस तर्क से कभी कोई डाउनवोट नहीं होगा। और डाउनवोट्स अपेक्षाकृत खराब उत्तरों को मात देने के लिए आवश्यक हैं। ओपी स्पष्ट रूप से एक शुरुआत है, और जीसी के विशिष्ट आंतरिक कामकाज केवल पूछे गए प्रश्न के लिए महत्वपूर्ण नहीं हैं। चूंकि यह उत्तर पूछे गए प्रश्न का उत्तर नहीं देता (यह एक अलग उत्तर देता है), डाउनवोट पूरी तरह से उचित हैं।
बिली ओपल

3

कचरा संग्रहकर्ता आपके कंप्यूटर को अनंत स्मृति वाले कंप्यूटर का अनुकरण करने की अनुमति देता है। बाकी सिर्फ तंत्र है।

यह पता लगाने के द्वारा किया जाता है कि मेमोरी के चंक्स अब आपके कोड से सुलभ नहीं हैं, और उन विखंडू को मुफ्त स्टोर में वापस कर रहे हैं।

संपादित करें: हां, लिंक सी # के लिए है, लेकिन सी # और जावा इस संबंध में समान हैं।


वास्तव में जावा और C # के GC के बीच के अंतर के बारे में SO पर एक प्रश्न है: stackoverflow.com/questions/492703/c-vs-java-gar
कचरा-collector

3

बहुत से लोग सोचते हैं कि कचरा एकत्र करना मृत वस्तुओं को इकट्ठा करता है और उनकी रक्षा करता है।
वास्तव में, जावा कचरा संग्रह विपरीत कार्य कर रहा है! लाइव ऑब्जेक्ट्स को ट्रैक किया जाता है और बाकी सब कुछ कचरा निर्दिष्ट किया जाता है।

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

अधिक विस्तार से जानकारी के लिए इसे देखें: http://javabook.compuware.com/content/memory/how-garbage-collection-works.aspx


1

इसे सबसे सरल शब्दों में रखने के लिए, जिसे एक गैर-प्रोग्रामर भी समझ सकता है, जब कोई प्रोग्राम उस डेटा को प्रोसेस करता है, तो उस डेटा के लिए इंटरमीडिएट डेटा और स्टोरेज स्पेस (वेरिएबल्स, एरेज़, कुछ ऑब्जेक्ट मेटाडेटा आदि) बनाता है।

जब ये ऑब्जेक्ट फ़ंक्शंस या एक निश्चित आकार से अधिक तक पहुंच जाते हैं, तो उन्हें एक केंद्रीय ढेर से आवंटित किया जाता है। फिर जब उन्हें लंबे समय की जरूरत नहीं होती है, तो उन्हें साफ करने की आवश्यकता होती है।

यह कैसे काम करता है इसके बारे में ऑनलाइन कुछ बहुत अच्छे लेख हैं, इसलिए मैं अभी बहुत मूल परिभाषा को कवर करूंगा।

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

बड़ी समस्या यह है कि कुछ हिस्सों में इस प्रक्रिया में अक्सर पूरे जावा वीएम को अस्थायी रूप से जगह लेने के लिए रोकना पड़ता है, साथ ही यह पूरी प्रक्रिया बहुत प्रोसेसर और मेमोरी बैंडविड्थ गहन होने की आवश्यकता होती है। GCs के रूप में विभिन्न विकल्प और हर एक के लिए ट्यूनिंग विकल्प पूरे GC प्रक्रिया के साथ इन विभिन्न मुद्दों को संतुलित करने के लिए डिज़ाइन किए गए हैं।


0

जावा (और अन्य भाषाओं / प्लेटफार्मों में) के रूप में कचरा संग्रह जावा रन-टाइम पर्यावरण (JRE) के लिए एक तरह से जावा ऑब्जेक्ट से मेमोरी का पुन: उपयोग करने का एक तरीका है जिसकी अब आवश्यकता नहीं है। सरलीकृत रूप से, जब JRE शुरू में शुरू होता है, तो यह एक निश्चित मात्रा में मेमोरी के लिए ऑपरेटिंग सिस्टम (O / S) पूछता है। जैसा कि JRE आपके एप्लिकेशन को चलाता है, यह उस मेमोरी का उपयोग करता है। जब आपके एप्लिकेशन को उस मेमोरी का उपयोग किया जाता है, तो JRE का "कचरा कलेक्टर" साथ आता है और उस मेमोरी को आपके मौजूदा एप्लिकेशन के विभिन्न हिस्सों द्वारा उपयोग के लिए याद करता है। JRE का "कचरा कलेक्टर" एक पृष्ठभूमि कार्य है जो हमेशा चलता रहता है और सिस्टम को बेकार में चलाने के लिए कई बार चुनने की कोशिश करता है।

एक वास्तविक विश्व सादृश्य होगा कचरा पुरुष जो आपके घर में आते हैं और आपके रिसाइकिल योग्य कचरे को उठाते हैं ... अंततः, इसका अन्य तरीकों से अपने और / या अन्य लोगों द्वारा पुन: उपयोग किया जाता है।


0

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

कचरा संग्रहण आमंत्रण को कचरा संग्रहण नीतियों द्वारा नियंत्रित किया जाता है।

आप यहां कुछ डेटा प्राप्त कर सकते हैं। http://www.oracle.com/technetwork/java/gc-tuning-5-138395.html


1
जीसी को लागू करने के लिए संदर्भ गिनती एक घटिया तरीका है। मुझे नहीं लगता कि कोई भी प्रमुख JVM कार्यान्वयन इसका उपयोग करता है।
NullUserException

0

कचरा संग्राहक jvm का एक घटक है।

इसका उपयोग कचरा इकट्ठा करने के लिए किया जाता है जब कभी सीपीयू मुक्त हो जाता है।

यहां कचरा का मतलब अप्रयुक्त वस्तुओं से है जो मुख्य कार्यक्रम की पृष्ठभूमि में चलता है

मुख्य कार्यक्रम की स्थिति की निगरानी करना।


0

स्वचालित कचरा संग्रह हीप मेमोरी को देखने की प्रक्रिया है, यह पहचान कर कि कौन सी वस्तुएं उपयोग में हैं और कौन सी नहीं हैं और अप्रयुक्त वस्तुओं को हटा रही हैं। उपयोग की वस्तु, या संदर्भित वस्तु में, का अर्थ है कि आपके कार्यक्रम का कुछ हिस्सा अभी भी उस वस्तु के लिए एक संकेतक रखता है। एक अप्रयुक्त वस्तु, या अप्रतिबंधित वस्तु, अब आपके कार्यक्रम के किसी भी हिस्से से संदर्भित नहीं है। तो एक अप्रतिबंधित वस्तु द्वारा उपयोग की जाने वाली मेमोरी को पुनः प्राप्त किया जा सकता है।

C जैसी प्रोग्रामिंग भाषा में, मेमोरी आवंटित करना और डील करना एक मैन्युअल प्रक्रिया है। जावा में, मेमोरी कलेक्टर से निपटने की प्रक्रिया को कचरा कलेक्टर द्वारा स्वचालित रूप से नियंत्रित किया जाता है। कृपया बेहतर समझ के लिए लिंक की जाँच करें। http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html


0

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


1
पाठ के लिए उद्धरण स्वरूपण का उपयोग न करें जो उद्धृत नहीं किया गया है, और यदि यह उद्धृत किया गया है तो आपको स्रोत का हवाला देने की आवश्यकता है।
लोरेन का मार्किस

0

कचरा संग्रह के मूल सिद्धांत एक कार्यक्रम में डेटा ऑब्जेक्ट को खोजना है जो भविष्य में एक्सेस नहीं किया जा सकता है, और उन वस्तुओं के लिए उपयोग किए गए संसाधनों को पुनः प्राप्त करने के लिए। 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 वस्तुओं है कि आवेदन जीवन के दौरान रहते हैं, उदाहरण के लिए, कक्षाएं, पुस्तकालयों के लिए के लिए।


0

जैसा कि ऑब्जेक्ट्स को नए ऑपरेटर द्वारा गतिशील रूप से आवंटित किया जाता है , आप पूछ सकते हैं कि ये ऑब्जेक्ट कैसे नष्ट हो जाते हैं और मेमोरी को कैसे मुक्त किया जाता है। सी ++ जैसी अन्य भाषाओं में, आपको डिलीट ऑपरेटर द्वारा गतिशील रूप से आवंटित वस्तुओं को मैन्युअल रूप से मुक्त करने की आवश्यकता है। जावा में एक अलग दृष्टिकोण है; यह स्वचालित रूप से डीलक्लोकेशन को संभालता है। तकनीक को कचरा संग्रह के रूप में जाना जाता है ।

यह इस तरह काम करता है: जब किसी ऑब्जेक्ट का कोई संदर्भ नहीं होता है, तो यह माना जाता है कि इस ऑब्जेक्ट की अब आवश्यकता नहीं है और आप ऑब्जेक्ट द्वारा कब्जा की गई मेमोरी को पुनः प्राप्त कर सकते हैं। C ++ की तरह वस्तुओं को स्पष्ट रूप से नष्ट करना आवश्यक नहीं है। कचरा निष्पादन कार्यक्रम निष्पादन के दौरान छिटपुट रूप से होता है; यह केवल इसलिए नहीं होता है क्योंकि एक या अधिक ऑब्जेक्ट हैं जो अब उपयोग नहीं किए जाते हैं। इसके अलावा, कई जावा रनटाइम कार्यान्वयन में कचरा संग्रहण के लिए अलग-अलग दृष्टिकोण हैं, लेकिन अधिकांश प्रोग्रामर को प्रोग्राम लिखते समय इसके बारे में चिंता करने की आवश्यकता नहीं है।


-2

स्वचालित कचरा संग्रह एक ऐसी प्रक्रिया है, जहां JVM से छुटकारा मिलता है या चल रहे कार्यक्रम के लिए स्थान खाली करने के लिए कुछ डेटा बिंदुओं को याद रखता है। मेमोरी को सबसे पहले मेमोरी को ढेर करने के लिए भेजा जाता है, यहीं पर कचरा संग्रहकर्ता (GC) अपना काम करता है, फिर उसे समाप्त करने या रखने का निर्णय लिया जाता है। जावा मानता है कि प्रोग्रामर पर हमेशा भरोसा नहीं किया जा सकता है, इसलिए यह उन वस्तुओं को समाप्त कर देता है जो यह सोचते हैं कि इसकी आवश्यकता नहीं है।

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