यदि मुझे अपने कार्यक्रम के पूरे जीवनकाल में स्मृति के एक टुकड़े का उपयोग करने की आवश्यकता है, तो क्या कार्यक्रम समाप्ति से ठीक पहले इसे मुक्त करना आवश्यक है?

Question

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

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

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

अब, मैं मानता हूं कि यह प्रश्न व्यापक है क्योंकि आपको अपनी स्मृति को कैसे संभालना चाहिए यह इस पर आधारित है कि आपको कितनी स्मृति की आवश्यकता है और जब आपको इसकी आवश्यकता हो, तो मैं इस प्रश्न के दायरे को इस तक सीमित कर दूंगा: यदि मुझे एक टुकड़े का उपयोग करने की आवश्यकता है मेरे कार्यक्रम के जीवनकाल में स्मृति, क्या कार्यक्रम समाप्ति से ठीक पहले इसे मुक्त करना आवश्यक है?

संपादित करें: एक डुप्लिकेट के रूप में सुझाए गए सवाल ऑपरेटिंग सिस्टम के यूनिक्स परिवार के लिए विशिष्ट थे। इसका शीर्ष उत्तर भी लिनक्स के लिए विशिष्ट उपकरण निर्दिष्ट करता है (जैसे Valgrind)। यह सवाल सबसे "सामान्य" गैर-एम्बेडेड ऑपरेटिंग सिस्टम को कवर करने के लिए है और यह एक प्रोग्राम के जीवनकाल में आवश्यक मुक्त मेमोरी के लिए एक अच्छा अभ्यास क्यों नहीं है या नहीं है।

Comments

देखें: programmers.stackexchange.com/questions/140483/…

— ब्रेंडन

आपने इस भाषा को अज्ञेय को टैग किया है, लेकिन कई भाषाओं (जैसे जावा) में मेमोरी को मैन्युअल रूप से मुक्त करना आवश्यक नहीं है; किसी वस्तु के अंतिम संदर्भ के दायरे से बाहर जाने के कुछ समय बाद यह स्वतः हो जाता है

— रिचर्ड टिंगल

और निश्चित रूप से आप C ++ को बिना किसी डिलीट के लिख सकते हैं और यह मेमोरी के लिए ठीक रहेगा

— Nikko

@RichardTingle, जबकि मैं C और शायद C ++ के अलावा अपने सिर के ऊपर से किसी अन्य भाषा के बारे में नहीं सोच सकता, भाषा-अज्ञेय टैग सभी भाषाओं को कवर करने के लिए था, जिसमें बहुत अधिक कचरा संग्रह उपयोगिताओं का निर्माण नहीं है। हालांकि यह आजकल दुर्लभ है। आप तर्क दे सकते हैं कि अब आप C ++ में ऐसी प्रणाली को लागू कर सकते हैं, लेकिन आपके पास अंततः स्मृति का एक टुकड़ा नहीं हटाने का विकल्प है।

— कप्तानओबरी

आप लिखते हैं: "कर्नेल मूल रूप से सभी संसाधनों को साफ करने की गारंटी है [...] कार्यक्रम समाप्ति के बाद"। यह आम तौर पर गलत है, क्योंकि सब कुछ स्मृति नहीं है, एक हैंडल या कर्नेल ऑब्जेक्ट है। लेकिन यह स्मृति के लिए सच है, जिससे आप तुरंत अपने प्रश्न को प्रतिबंधित कर देते हैं।

— एरिक टॉवर्स

Answer 1

यदि मुझे अपने कार्यक्रम के पूरे जीवनकाल में स्मृति के एक टुकड़े का उपयोग करने की आवश्यकता है, तो क्या कार्यक्रम समाप्ति से ठीक पहले इसे मुक्त करना आवश्यक है?

यह अनिवार्य नहीं है, लेकिन इसके फायदे (साथ ही कुछ कमियां भी) हो सकते हैं।

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

हालाँकि, निष्पादन के अंत में सभी मेमोरी को स्पष्ट रूप से जारी करके,

• डिबगिंग / परीक्षण के दौरान, मेम लीक डिटेक्शन टूल आपको "गलत सकारात्मक" नहीं दिखाएंगे
• यह कोड को स्थानांतरित करने के लिए बहुत आसान हो सकता है जो एक अलग घटक में मेमोरी और आवंटन के साथ एक साथ उपयोग करता है और इसे बाद में एक अलग संदर्भ में उपयोग करता है जहां घटक के उपयोगकर्ता द्वारा मेमोरी के उपयोग के समय को नियंत्रित करने की आवश्यकता होती है

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

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

Comments

अच्छी प्रोग्रामिंग आदतों को विकसित करने के बारे में अच्छी बात।

— लॉरेंस

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

— ग्रैंडऑपनर

यह हर आधुनिक "सामान्य" (मेमोरी सुरक्षा के साथ गैर-एम्बेडेड) ओएस पर सुरक्षित है, और अगर यह नहीं था तो एक गंभीर बग होगा। अगर एक अनपेक्षित प्रक्रिया स्थायी रूप से मेमोरी खो सकती है जिसे ओएस पुनः प्राप्त नहीं करेगा, तो इसे कई बार चलाने से सिस्टम मेमोरी से बाहर चला सकता है। ओएस का दीर्घकालिक स्वास्थ्य अप्रकाशित कार्यक्रमों में बग की कमी पर निर्भर नहीं कर सकता है। (बेशक, यह यूनिक्स साझा-मेमोरी सेगमेंट जैसी चीजों की अनदेखी कर रहा है, जो केवल स्वैप स्पेस द्वारा समर्थित हैं।)

— पीटर कॉर्ड्स

@GrandOpener इस मामले में आप इस पेड़ के लिए कुछ प्रकार के क्षेत्र-आधारित आवंटनकर्ता का उपयोग करना पसंद कर सकते हैं, ताकि आप इसे सामान्य तरीके से आवंटित कर सकें और समय आने पर पूरे क्षेत्र को एक बार में निपटा सकें, बजाय इसे खोदने और मुक्त करने के यह बिट द्वारा है। वह अभी भी "उचित" है।

— थॉमस

इसके अतिरिक्त, यदि मेमोरी को वास्तव में कार्यक्रम के पूरे जीवनकाल के लिए मौजूद रहने की आवश्यकता है, तो यह स्टैक पर एक संरचना बनाने के लिए एक समझदार विकल्प हो सकता है, उदाहरण के लिए main।

— काइल स्ट्रैंड

Answer 2

चलाए जा रहे कार्यक्रमों के अंत में मेमोरी को खाली करना सीपीयू समय की बर्बादी है। यह एक घर को कक्षा से बाहर निकालने से पहले उसे बांधने जैसा है।

हालाँकि कभी-कभी जो कम चलने वाला कार्यक्रम होता था वह बहुत लंबे समय तक चलने वाले हिस्से में बदल सकता है। फिर मुफ्त सामान आवश्यक हो जाता है। अगर इस बारे में कम से कम कुछ हद तक सोचा नहीं गया था, तो इसमें काफी हद तक काम शामिल हो सकता है।

इसका एक चतुर समाधान "लोंगो" है जो आपको मेमोरी आवंटन का भार देता है और फिर एक कॉल के साथ उन्हें दूर फेंक देता है।

Comments

मान लें कि आपको पता है कि आपके ओएस का अपना लीक नहीं है।

— WGroleau 5

"CPU समय की बर्बादी" हालांकि बहुत, बहुत कम समय। freeआमतौर पर की तुलना में बहुत तेज है malloc।

— पॉल ड्रेपर

@PaulDraper ऐ, समय की बर्बादी के लिए सब कुछ वापस करने के लिए बहुत अधिक महत्वपूर्ण है।

— डेडुप्लिकेटर

Answer 3

आप कचरा संग्रहण (जैसे स्कीम, ओकेमेल, हास्केल, कॉमन लिस्प और यहां तक ​​कि जावा, स्काला, क्लोजर) के साथ एक भाषा का उपयोग कर सकते हैं ।

^{(सबसे जीसी एड भाषाओं में, वहाँ है कोई रास्ता नहीं करने के लिए स्पष्ट रूप से और मैन्युअल ! मुक्त स्मृति कभी कभी, कुछ मान हो सकता है अंतिम रूप दे दिया है, जैसे जी सी और क्रम प्रणाली , लेकिन यह नहीं है, एक फ़ाइल हैंडल मूल्य को बंद होगा जब कि मूल्य पहुंच योग्य नहीं है निश्चित रूप से अविश्वसनीय, और आपको इसके बजाय अपनी फ़ाइल के हैंडल को स्पष्ट रूप से बंद करना चाहिए , क्योंकि अंतिम रूप देने की गारंटी नहीं है)}

आप अपने प्रोग्राम के लिए C (या यहां तक ​​कि C ++) में कोडित भी कर सकते हैं, Boehm के रूढ़िवादी कचरा संग्रहकर्ता का उपयोग करें । इसके बाद आप अपने सभी जगह लेंगे mallocसाथ GC_malloc और के बारे में परेशान नहीं freeकिसी भी सूचक आईएनजी। बेशक आपको बोहम की जीसी का उपयोग करने के पेशेवरों और विपक्षों को समझने की आवश्यकता है। जीसी हैंडबुक भी पढ़ें ।

^{मेमोरी प्रबंधन एक कार्यक्रम की एक वैश्विक संपत्ति है। किसी तरह से यह (और कुछ दिए गए आंकड़ों की परत) पूरे कार्यक्रम की संपत्ति के बाद से गैर-रचनात्मक और गैर-मॉड्यूलर है।}

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

यदि मुझे अपने कार्यक्रम के पूरे जीवनकाल में स्मृति के एक टुकड़े का उपयोग करने की आवश्यकता है, तो क्या कार्यक्रम समाप्ति से ठीक पहले इसे मुक्त करना आवश्यक है?

नहीं, आपको ऐसा करने की आवश्यकता नहीं है। और कई वास्तविक विश्व कार्यक्रम कुछ मेमोरी को मुक्त करने में परेशान नहीं करते हैं, जो पूरे जीवनकाल में आवश्यक है (विशेष रूप से जीसीसी संकलक इसकी कुछ मेमोरी को मुक्त नहीं कर रहा है)। हालाँकि, जब आप ऐसा करते हैं (जैसे कि आप सी-डायनामिक रूप से आवंटित डेटा के freeकुछ विशेष टुकड़े को परेशान नहीं करते हैं ), तो आप उसी परियोजना पर भविष्य के प्रोग्रामर के काम को आसान बनाने के लिए उस तथ्य पर बेहतर टिप्पणी करेंगे । मैं सिफारिश करता हूं कि अनफ्रीर्ड मेमोरी की मात्रा सीमित रहती है, और आमतौर पर कुल इस्तेमाल की गई ढेर मेमोरी के लिए अपेक्षाकृत छोटा wrt।

ध्यान दें कि सिस्टम freeअक्सर ओएस को मेमोरी जारी नहीं करता है (जैसे POSIX सिस्टम पर मूनमैप (2) को कॉल करके ), लेकिन आमतौर पर भविष्य द्वारा पुन: प्रयोज्य के रूप में एक मेमोरी ज़ोन को चिह्नित करता है malloc। विशेष रूप से, वर्चुअल एड्रेस स्पेस (जैसे कि /proc/self/mapsलिनक्स पर थ्रू को देखा जाता है , देखें proc (5) ....) के बाद सिकुड़ नहीं सकता है free(इसलिए उपयोगिताओं psया topआपकी प्रक्रिया के लिए उपयोग की गई मेमोरी की समान मात्रा की रिपोर्ट कर रहा है)।

Comments

"कभी-कभी, कुछ मानों को अंतिम रूप दिया जा सकता है, उदाहरण के लिए GC और रनटाइम सिस्टम एक फ़ाइल हैंडल वैल्यू को बंद कर देगा जब वह मान अगम्य हो" आप चाहते हो सकता है कि अधिकांश GCed भाषाओं में कोई गारंटी नहीं है कि कोई मेमोरी कभी भी पुनः प्राप्त होगी, और न ही किसी भी अंतिम रूप से कभी भी बाहर निकलें, यहां तक ​​कि बाहर निकलें: stackoverflow.com/questions/7880569/…

— Deduplicator

मैं व्यक्तिगत रूप से इस जवाब को पसंद करता हूं, क्योंकि यह हमें जीसी (यानी एक अधिक स्वचालित दृष्टिकोण) का उपयोग करने के लिए प्रोत्साहित करता है।

— ता थान

@tathanhdinh अधिक स्वचालित, हालांकि विशेष रूप से स्मृति के लिए। अन्य सभी संसाधनों के लिए पूरी तरह से मैनुअल। जीसी व्यापार निर्धारण और स्मृति के सुविधाजनक संचालन के लिए स्मृति द्वारा काम करता है। और नहीं, फाइनल ज्यादा मदद नहीं करते हैं, और उनकी अपनी समस्याएं हैं।

— डिडुपिलेटर 19

Answer 4

यह आवश्यक नहीं है , क्योंकि आप अपने कार्यक्रम को ठीक से निष्पादित करने में विफल नहीं होंगे यदि आप असफल हो जाते हैं। हालाँकि, ऐसे कारण हैं जिन्हें आप मौका दे सकते हैं।

मेरे (ओवर और ओवर) सबसे शक्तिशाली मामलों में से एक यह है कि कोई अनुकार कोड का एक छोटा सा टुकड़ा लिखता है जो उनके निष्पादन में चलता है। वे कहते हैं "हम इस कोड को सिमुलेशन में एकीकृत करना चाहेंगे।" मैं फिर उनसे पूछता हूं कि वे मोंटे-कार्लो रनों के बीच फिर से इनिशियलाइज़ करने की योजना कैसे बनाते हैं, और वे मुझे खाली देखते हैं। "क्या मतलब है आप फिर से शुरू करें? आप सिर्फ नई सेटिंग्स के साथ कार्यक्रम चलाते हैं?"

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

उदाहरण के लिए कि कैसे अजीब चीजें मिल सकती हैं, प्रक्रियाओं के अंत में प्रबंधित भाषाओं को अंतिम रूप देने के तरीके, या अनुप्रयोग डोमेन के क्रमिक ठहराव के साथ C # कैसे व्यवहार करता है, इसे देखें। वे खुद को गांठों में बांध लेते हैं क्योंकि ऐसी धारणाएं हैं जो इन चरम मामलों में दरार के माध्यम से गिरती हैं।

Answer 5

उन भाषाओं को अनदेखा करना जहाँ आप किसी भी तरह से मैन्युअल रूप से मेमोरी मुक्त नहीं करते हैं ...

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

Comments

ऐसा लगता है कि कुछ ही घंटों पहले पोस्ट किए गए शीर्ष उत्तर में केवल रिपीट पॉइंट (और बहुत बेहतर समझाया गया) : "कोड को स्थानांतरित करने में बहुत आसान हो सकता है जो एक अलग घटक में आवंटन और डिक्लोकेशन के साथ मेमोरी का उपयोग करता है और बाद में इसका उपयोग करता है। एक अलग संदर्भ में, जहां मेमोरी के उपयोग के समय को घटक के उपयोगकर्ता द्वारा नियंत्रित करने की आवश्यकता है ... "

— gnat

Answer 6

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

चीजों को करें जबकि उनके बारे में आपकी समझ अभी भी ताजा है।

यह एक छोटा निवेश है जो भविष्य में बड़ा लाभ दे सकता है।

Comments

यह पहले किए गए 11 अंकों में कुछ भी जोड़ नहीं पाया और समझाया गया। विशेष रूप से, भविष्य में कार्यक्रम को संभवतः बदलने के बारे में तीन या चार बार पहले ही बात की जा चुकी है

— gnat

@gnat एक जटिल और अस्पष्ट तरीके से - हाँ। एक स्पष्ट बयान में - नहीं। आइए उत्तर गुणवत्ता पर ध्यान दें, न कि गति पर।

— Agent_L

गुणवत्ता के मामले में, शीर्ष उत्तर इस बिंदु को समझाने में बहुत बेहतर प्रतीत होता है

— gnat

Answer 7

नहीं, यह आवश्यक नहीं है, लेकिन यह एक अच्छा विचार है।

आप कहते हैं कि आपको लगता है कि "रहस्यमय और भयानक चीजें होती हैं अगर मैं इसे इस्तेमाल करने के बाद मेमोरी को मुक्त नहीं करता।"

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

बेशक इसका अतिरिक्त लाभ यह है कि आपके कोड का फिर से उपयोग और अनुकूलित किया जा सकता है, जैसा कि अन्य लोगों ने कहा है।

हालांकि , कम से कम एक मामला है जहां कार्यक्रम समाप्ति से ठीक पहले स्मृति को मुक्त नहीं करना बेहतर है ।

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

यदि इसके बजाय कार्यक्रम सिर्फ गर्भपात करता है, तो ओएस डिस्क को स्वैप करने वाली सभी मेमोरी को छोड़ देगा, जो लगभग तात्कालिक है क्योंकि इसमें किसी भी डिस्क का उपयोग करने की आवश्यकता नहीं है।

यह ध्यान रखना महत्वपूर्ण है कि एक ओओ भाषा में, ऑब्जेक्ट के डिस्ट्रक्टर को कॉल करना भी मेमोरी को स्वैप करने के लिए मजबूर करेगा; अगर आपको ऐसा करना है तो आप मेमोरी को फ्री कर सकते हैं।

Comments

क्या आप इस विचार का समर्थन करने के लिए कुछ उद्धृत कर सकते हैं कि पृष्ठबद्ध-आउट मेमोरी को डीलॉलेट करने के लिए पृष्ठांकित करने की आवश्यकता है? यह स्पष्ट रूप से अक्षम है, निश्चित रूप से आधुनिक ओएस इससे अधिक चालाक हैं!

@ ऑल ट्रेड्स के, आधुनिक ओएस स्मार्ट हैं, लेकिन विडंबना यह है कि अधिकांश आधुनिक भाषाएं नहीं हैं। जब आप मुक्त (कुछ) करते हैं, तो संकलक स्टैक पर "कुछ" डाल देगा, फिर मुफ्त () कॉल करें। यदि इसे बाहर स्वैप किया जाता है, तो इसे स्टैक पर रखने से इसे वापस रैम में स्वैप करने की आवश्यकता होती है।

— जेफिकिन्स

@JonofAllTrades एक मुक्त-सूची में वह प्रभाव होगा, जो हालांकि एक अप्रचलित अप्रचलित कार्यान्वयन है। लेकिन OS आपको ऐसे कार्यान्वयन का उपयोग करने से नहीं रोक सकता है।

Answer 8

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

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

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