कचरा संग्रह का कारण यह है कि सी जैसी भाषा में जहां स्मृति प्रबंधन पूरी तरह से प्रोग्रामर के स्पष्ट नियंत्रण में है, जब ऑब्जेक्ट स्वामित्व पारित हो जाता है, विशेष रूप से धागे या यहां तक कि कठिन, मेमोरी साझा करने वाली प्रक्रियाओं के बीच, मेमोरी लीक से बचने और लटकने वाले पॉइंटर्स बहुत मुश्किल हो सकते हैं। यदि वह काफी कठिन नहीं थे, तो आपको एक समय में स्मृति में फिट होने की अपेक्षा अधिक वस्तुओं तक पहुंचने की आवश्यकता से निपटना होगा-आपको कुछ वस्तुओं को थोड़ी देर तक मुक्त करने का एक तरीका होना चाहिए ताकि अन्य ऑब्जेक्ट्स स्मृति में हो सकता है।
तो, कुछ भाषाएं (उदाहरण के लिए, पर्ल, लिस्प, जावा) एक ऐसी तंत्र प्रदान करती हैं जहां आप किसी ऑब्जेक्ट का उपयोग करके "केवल" रोक सकते हैं और कचरा कलेक्टर अंततः यह खोज लेगा और ऑब्जेक्ट के लिए उपयोग की गई मेमोरी को मुक्त कर देगा। प्रोग्रामर के बिना यह सही तरीके से करता है कि वे इसे गलत तरीके से प्राप्त कर सकते हैं (हालांकि कई तरह के प्रोग्रामर इसे पेंच कर सकते हैं)।
यदि आप किसी ऑब्जेक्ट के मूल्य की गणना करने के लिए किसी ऑब्जेक्ट तक पहुंचने की संख्या को संकल्पनात्मक रूप से गुणा करते हैं, और ऑब्जेक्ट को आसानी से उपलब्ध नहीं होने या किसी के आकार के द्वारा संभवतः फिर से गुणा करें ऑब्जेक्ट मेमोरी में चारों ओर एक बड़ी वस्तु रखने के बाद से कई छोटी वस्तुओं को चारों ओर रखने से रोक सकता है, आप वस्तुओं को तीन श्रेणियों में वर्गीकृत कर सकते हैं।
कुछ वस्तुएं इतनी महत्वपूर्ण हैं कि आप अपने अस्तित्व को स्पष्ट रूप से प्रबंधित करना चाहते हैं-वे कचरा कलेक्टर द्वारा प्रबंधित नहीं किए जाएंगे या उन्हें स्पष्ट रूप से मुक्त होने तक कभी भी एकत्र नहीं किया जाना चाहिए। कुछ वस्तुएं गणना करने के लिए सस्ते होती हैं, छोटी होती हैं, अक्सर उपयोग नहीं की जाती हैं या समान विशेषताएं होती हैं जो उन्हें किसी भी समय कचरा इकट्ठा करने देती हैं।
तीसरी कक्षा, ऑब्जेक्ट्स जो कि महंगे होने के लिए महंगे हैं लेकिन फिर से कंप्यूम्प्यूट किए जा सकते हैं, कुछ हद तक अक्सर उपयोग किए जाते हैं (संभवत: थोड़े समय के लिए), बड़े आकार के होते हैं, और इसी तरह तीसरे वर्ग होते हैं। आप उन्हें यथासंभव स्मृति में रखना चाहते हैं क्योंकि उन्हें फिर से उपयोग किया जा सकता है, लेकिन आप महत्वपूर्ण वस्तुओं के लिए आवश्यक स्मृति से बाहर नहीं निकलना चाहते हैं। ये कमजोर संदर्भों के लिए उम्मीदवार हैं।
आप इन वस्तुओं को यथासंभव लंबे समय तक रखना चाहते हैं यदि वे महत्वपूर्ण संसाधनों के साथ संघर्ष नहीं कर रहे हैं, लेकिन यदि उन्हें महत्वपूर्ण संसाधन के लिए स्मृति की आवश्यकता होती है तो उन्हें छोड़ दिया जाना चाहिए क्योंकि आवश्यकता होने पर इसे दोबारा दोबारा लगाया जा सकता है। ये टोपी कमजोर पॉइंटर्स हैं।
इसका एक उदाहरण चित्र हो सकता है। मान लें कि आपके पास एक फोटो वेब पेज है जिसमें हजारों चित्र प्रदर्शित होंगे। आपको यह जानने की जरूरत है कि कितने चित्रों को रखना है और शायद आपको सूची प्राप्त करने के लिए डेटाबेस क्वेरी करना है। कुछ हज़ार वस्तुओं की सूची रखने की स्मृति शायद बहुत छोटी है। आप एक बार प्रश्न करना चाहते हैं और इसे चारों ओर रखना चाहते हैं।
एक वेब पेज के एक फलक में, आप केवल एक समय में शारीरिक रूप से कुछ दर्जन चित्र दिखा सकते हैं। आपको उन चित्रों के लिए बिट्स लाने की आवश्यकता नहीं है जिन्हें उपयोगकर्ता नहीं देख सकता है। जब उपयोगकर्ता पृष्ठ को स्क्रॉल करता है, तो आप दृश्यमान चित्रों के लिए वास्तविक बिट एकत्र करेंगे। उन चित्रों को दिखाने के लिए कई मेगाबाइट की आवश्यकता हो सकती है। यदि उपयोगकर्ता कुछ स्क्रॉल स्थितियों के बीच आगे और पीछे स्क्रॉल करता है, तो आप उन मेगाबाइट को बार-बार रीफ्रैच नहीं करना चाहते हैं। लेकिन आप सभी चित्रों को हर समय स्मृति में नहीं रख सकते हैं। तो आप कमजोर पॉइंटर्स का उपयोग करते हैं।
यदि उपयोगकर्ता बस कुछ बार बार-बार चित्रों को देखता है, तो वे कैश में रह सकते हैं और आपको उन्हें रीफ्रैच करने की आवश्यकता नहीं है। लेकिन अगर वे पर्याप्त स्क्रॉल करते हैं, तो आपको कुछ मेमोरी खाली करने की ज़रूरत है ताकि दृश्य चित्रों को लाया जा सके। एक कमजोर संदर्भ के साथ, आप इसका उपयोग करने से ठीक पहले संदर्भ की जांच करें। यदि यह अभी भी मान्य है, तो आप इसका इस्तेमाल करते हैं। यदि ऐसा नहीं है, तो आप इसे प्राप्त करने के लिए महंगी गणना (fetch) बनाते हैं।
मुझे पता नहीं है ... शायद अगर आपको केवल अस्थायी रूप से डेटा तक पहुंच की आवश्यकता है, तो कचरा कलेक्टर इसे नियमित रूप से साफ़ कर देगा यदि यह नियमित सूचक था? – mpen