मेमोरी आवंटन: ढेर बनाम ढेर?

Question 1

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

अब निम्नलिखित उदाहरण पर विचार करें:

class MyClass
{
    int myInt = 0;    
    string myString = "Something";
}

class Program
{
    static void Main(string[] args)
    {
       MyClass m = new MyClass();
    }
}

अब, मेमोरी आवंटन c # में कैसे होगा? क्या MyClass(यानी m) का उद्देश्य पूरी तरह से हीप को आवंटित किया जाएगा? यही है, int myIntऔर string myStringदोनों ढेर जाएंगे?

या, ऑब्जेक्ट को दो भागों में विभाजित किया जाएगा और दोनों को उन मेमोरी स्थानों पर आवंटित किया जाएगा जो स्टैक और हीप हैं?

Question 2

mढेर पर आवंटित किया जाता है, और इसमें शामिल है myInt। उन स्थितियों पर जहां आदिम प्रकार (और संरचनाएं) स्टैक पर आवंटित की जाती हैं, विधि आह्वान के दौरान होती है, जो स्टैक पर स्थानीय चर के लिए कमरा आवंटित करती है (क्योंकि यह तेज है)। उदाहरण के लिए:

class MyClass
{
    int myInt = 0;

    string myString = "Something";

    void Foo(int x, int y) {
       int rv = x + y + myInt;
       myInt = 2^rv;
    }
}

rv, x, yसभी ढेर पर होगा। myIntढेर पर कहीं है (और thisसूचक के माध्यम से पहुंच होनी चाहिए )।

Question 3

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

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

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

क्या मुझे कुछ याद है?

अगर मैं इस विषय पर एरिक लिपर्ट के पोस्ट से लिंक नहीं करता, तो निश्चित रूप से मुझे याद होगा:

स्टैक इम्प्लीमेंटेशन डिटेल, पार्ट वन है
स्टैक इम्प्लीमेंटेशन डिटेल, पार्ट टू
और शायद सबसे अच्छा: मूल्य प्रकार के बारे में सच्चाई

Question 4

"सभी मूल्यवान प्रकारों को ढेर के लिए आवंटित किया जाएगा" बहुत गलत है; संरचना चर , विधि चर के रूप में, स्टैक पर रह सकते हैं। हालाँकि, एक प्रकार के फ़ील्ड उस प्रकार के साथ रहते हैं । यदि किसी क्षेत्र का घोषित प्रकार एक वर्ग है, तो मान उस वस्तु के हिस्से के रूप में ढेर पर हैं । यदि किसी फ़ील्ड का घोषित प्रकार एक संरचना है, तो फ़ील्ड उस संरचना का हिस्सा होते हैं, जहां कभी-कभी वह संरचना रहती है।

यहां तक कि विधि चर भी ढेर पर हो सकते हैं, यदि वे कैप्चर किए गए हैं (लंबो / एनॉन-विधि), या एक इटैलर ब्लॉक का हिस्सा (उदाहरण के लिए)।

Question 5

उत्कृष्ट स्पष्टीकरण:

Question 6

ढेर

stackभंडारण के लिए स्मृति का एक ब्लॉक है local variablesऔर parameters। स्टैक तार्किक रूप से बढ़ता है और एक फ़ंक्शन में प्रवेश और बाहर निकलने के लिए सिकुड़ता है।

निम्नलिखित विधि पर विचार करें:

public static int Factorial (int x)
{
    if (x == 0) 
    {
        return 1;
    }

    return x * Factorial (x - 1);
}

यह विधि पुनरावर्ती है, जिसका अर्थ है कि यह खुद को कहता है। हर बार जब विधि दर्ज की जाती है, तो स्टैक पर एक नया इंट आवंटित किया जाता है , और हर बार विधि से बाहर निकलने के बाद, इंट को हटा दिया जाता है ।

ढेर

ढेर स्मृति का एक खंड है जिसमें objects(यानी, reference-type instances) निवास करता है। जब भी कोई नई वस्तु बनाई जाती है, तो उसे ढेर पर आवंटित किया जाता है, और उस वस्तु का एक संदर्भ वापस कर दिया जाता है। एक कार्यक्रम के निष्पादन के दौरान, नई वस्तुओं का निर्माण होते ही ढेर भरना शुरू हो जाता है। रनटाइम में एक कचरा संग्राहक होता है जो समय-समय पर ढेर से वस्तुओं को हटाता है, इसलिए आपका प्रोग्राम नहीं चलता है Out Of Memory। एक वस्तु सौदा करने के लिए योग्य है जैसे ही यह किसी भी चीज से संदर्भित नहीं है जो स्वयं है alive।

ढेर भी संग्रहीत करता है static fields। ढेर पर आवंटित वस्तुओं के विपरीत (जो कचरा एकत्र कर सकते हैं) these live until the application domain is torn down,।

निम्नलिखित विधि पर विचार करें:

using System;
using System.Text;

class Test
{
    public static void Main()
    {
        StringBuilder ref1 = new StringBuilder ("object1");
        Console.WriteLine (ref1);
        // The StringBuilder referenced by ref1 is now eligible for GC.

        StringBuilder ref2 = new StringBuilder ("object2");
        StringBuilder ref3 = ref2;
        // The StringBuilder referenced by ref2 is NOT yet eligible for GC.
        Console.WriteLine (ref3); // object2
    }
}

उपरोक्त उदाहरण में, हम चर Ref1 द्वारा संदर्भित StringBuilder वस्तु बनाकर शुरू करते हैं, और फिर इसकी सामग्री लिखते हैं। वह स्ट्रिंगबुलस्ट वस्तु तब कचरा संग्रहण के लिए तुरंत योग्य है, क्योंकि बाद में कुछ भी इसका उपयोग नहीं करता है। फिर, हम वैरिएबल Ref2 द्वारा संदर्भित एक और StringBuilder बनाते हैं, और उस संदर्भ को Ref3 में कॉपी करते हैं। हालांकि उस बिंदु के बाद Ref2 का उपयोग नहीं किया जाता है, फिर भी Ref3 उसी StringBuilder वस्तु को जीवित रखता है - यह सुनिश्चित करते हुए कि यह संग्रह के लिए योग्य नहीं है जब तक कि हम ref3 का उपयोग करके समाप्त नहीं हो जाते।

जहाँ भी वैरिएबल घोषित किया गया था, वहाँ वैल्यू-टाइप इंस्टेंस (और ऑब्जेक्ट संदर्भ) रहते हैं। यदि उदाहरण को एक वर्ग प्रकार के भीतर या एक सरणी तत्व के रूप में क्षेत्र के रूप में घोषित किया गया था, तो वह उदाहरण ढेर पर रहता है।

Question 7

सरल उपाय

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

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

संदर्भ प्रकारों को संदर्भ द्वारा पास किया जाता है (सहमत नहीं मानते कि संदर्भ भविष्य के कुछ संस्करणों में एक पते को फिर से संग्रहीत करेगा, इसे कुछ अन्य डेटा संरचनाओं पर संग्रहीत किया जा सकता है।)

आपके मामले में ऐसा है

myInt एक ऐसा उदाहरण है जिसे एक वर्ग में रखा गया है जो एक संदर्भ प्रकार को ऑफ़कोर्स करता है इसलिए इसे उस वर्ग के उदाहरण से जोड़ा जाएगा जिसे 'THE HEAP' पर संग्रहीत किया जाएगा।

मेरा सुझाव है, आप ERIC LIPPERTS द्वारा लिखे गए ब्लॉग पढ़ना शुरू कर सकते हैं।

एरिक का ब्लॉग

Question 8

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

यह लिंक उपयोगी भी है http://www.programmerinterview.com/index.php/data-structures/difference-between-stack-and-heap/

Question 9

मी MyClass की एक ऑब्जेक्ट का संदर्भ है इसलिए m मुख्य धागे के ढेर में स्टोर है लेकिन ढेर में MyClass स्टोर की वस्तु। इसलिए ढेर में myInt और myString स्टोर। ध्यान दें कि मी केवल एक संदर्भ (मेमोरी के लिए एक पता) है और मुख्य स्टैक पर है। जब एम डील किया गया तो GC ने ढेर से MyClass ऑब्जेक्ट को साफ़ कर दिया। अधिक विवरण के लिए इस लेख के सभी चार भागों को पढ़ें https://www.c-sharpcorner.com/article/C-Sharp-heaping-vs-stacking-in-net- भाग- i /