एक .net अनुप्रयोग का जीवन चक्र

Question

एक सरल .net .exe अनुप्रयोग होने का क्या है। एक बार निष्पादित होने पर इसका जीवन चक्र क्या है। (कृपया विस्तृत करने के लिए स्वतंत्र महसूस), मैं अंतिम चरण में, जब CLR लोड विधानसभाओं में दिलचस्पी रखता हूँ

> 1. OS loads exe assemblies into memory 
> 2. OS checks if it is in fact .net assembly 
> 3. mscoree.dll loads, and loads CLR 
> 4. CLR takes over and loads external dlls, GC stuff, memory management etc. 
> 5. CLR creates app domain where exe assemblies are loaded 
> 6. exe is started 

ऊपर देखते हुए सही है: मैं समझता हूँ कि निम्नलिखित होता है।

1. कितने ढेर, ढेर, धागे बनाए जाते हैं? क्या धागा बनाया गया है और निष्पादन योग्य के भीतर कोड निष्पादित करता है?
2. आवंटित प्रारंभिक स्मृति का आकार क्या है ?, जो मेमोरी आवंटित करता है (ओएस या सीएलआर?)
3. यह कैसे पता चलता है कि शुरुआत में कितनी मेमोरी की आवश्यकता है?
4. यदि exe चलाता है तो अधिक स्मृति की आवश्यकता होती है, जो यह तय करता है कि इस स्मृति को कितना और कब आवंटित किया जाए?
5. जब आप एक्सई बंद करते हैं तो क्या होता है ?, क्या सीएलआर ऐप डोमेन को उतारने से पहले किसी भी जीसी को चलाता है? (exe बंद), या ओएस करता है?

Answer 1

ठीक है, प्रक्रिया आपके द्वारा लिखी गई तुलना में थोड़ा अधिक जटिल है। कुछ चरणों में से एक से थोड़ा अधिक सोच सकता है - उदाहरण के लिए, चरण 1 और पीई कैसे लोड किया गया (और mscoree.dll स्वयं लोड हो गया) में आंतरिक-चरण शामिल हैं।

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

कचरा कलेक्टर के मूलभूत सिद्धांतों के बारे में कुछ अच्छे एमएसडीएन लेख भी हैं जो आपको दिलचस्प लग सकते हैं।

कितने ढेर, ढेर, धागे बनाए जाते हैं? क्या धागा बनाया गया है और निष्पादन योग्य के भीतर कोड निष्पादित करता है?

सरल (खाली) कंसोल एप्लिकेशन में 3 धागे होंगे: मुख्य धागा, जीसी थ्रेड और फाइनलाइज़र थ्रेड। बेशक, प्रत्येक धागे का अपना ढेर होता है (प्रत्येक 1 एमबी)।

ढेर की संख्या आपके द्वारा उपयोग किए जा रहे जीसी प्रकार पर निर्भर करती है। यदि आप वर्कस्टेशन जीसी (डिफ़ॉल्ट) का उपयोग कर रहे हैं तो 1 प्रबंधित ढेर होगा (2 सेगमेंट के साथ, एक "सामान्य" ऑब्जेक्ट्स के लिए और एक बड़ा ऑब्जेक्ट हीप सेगमेंट होगा)।

यदि आप सर्वर जीसी के साथ काम कर रहे हैं तो सिस्टम में उपलब्ध प्रत्येक लॉजिकल कोर के लिए 1 ढेर होगा (प्रत्येक सेगमेंट में से प्रत्येक ढेर के साथ)।

क्या आवंटित प्रारंभिक स्मृति के आकार है ?, जो स्मृति (ओएस या CLR?)

प्रारंभिक स्मृति एक से अधिक तत्व होता है आवंटित: वहाँ प्रत्येक थ्रेड के लिए 1 एमबी ढेर है , प्रक्रिया में लोड की गई छवियों का आकार (जो आपके आवेदन के आधार पर निर्भर करता है), और आकार का "गतिशील" तत्व है - आपके आवेदन में आवंटित आवंटन, जिससे जीसी ढेर के आकार में वृद्धि, और जिन वस्तुओं का आप अब उपयोग नहीं कर रहे हैं, वे जीसी द्वारा साफ किए गए हैं और जीसी को स्मृति मुक्त कर सकते हैं।

यदि exe चलाता है तो अधिक स्मृति की आवश्यकता होती है, जो यह तय करता है कि इस स्मृति को कितना और कब आवंटित किया जाए?

यदि आपके पास एक साधारण कंसोल एप्लिकेशन है, तो मुख्य के अंदर आप एक नई कक्षा का उदाहरण बनाते हैं। उस स्थिति में, "नया" कीवर्ड (सीआईएल "newobj" निर्देश) सीएलआर आवश्यक स्मृति की गणना करेगा।

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

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

यदि exe चलाता है तो अधिक स्मृति की आवश्यकता होती है, जो यह तय करता है कि इस स्मृति को कितना और कब आवंटित किया जाए?

सभी अपनी प्रक्रिया में बनाए गए नए वस्तुओं के लिए स्मृति आवंटन CLR ही द्वारा किया जाता है (जाहिर है, आभासी स्मृति में ही प्रबंध इस तरह के VirtualAlloc और VirtualFree, और खिड़कियों के रूप में CLR उपयोग विंडोज एपीआई)।

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

जब आप एक्सई बंद करते हैं तो क्या होता है ?, क्या सीएलआर ऐप डोमेन को उतारने से पहले किसी भी जीसी को चलाता है? (exe बंद), या ओएस करता है?

सीएलआर किसी भी ऐप-डोमेन को उतारने से पहले त्वरित जीसी चलाता है। इस त्वरित जीसी का उद्देश्य अंतिम रूप से चलाने का मौका देना है। प्रक्रिया को बंद करते समय, सीएलआर को स्मृति को साफ करने की कोई आवश्यकता नहीं है, क्योंकि ओएस वैसे भी करता है।

आशा है कि यह मदद करता है।

Answer 2

कितने ढेर, ढेर, धागे बनाए जाते हैं?

प्रक्रिया में, जिसमें आप आवेदन करते हैं, वहां कई धागे हो सकते हैं। हालांकि, उनमें से एक निष्पादन का मुख्य धागा होगा।

जब कोई धागा बनाया जाता है तो इसे 1-एमबी स्टैक आवंटित किया जाता है।

जो स्मृति (ओएस या CLR?)

के रूप में कहा गया है here

आम भाषा क्रम के कचरा कलेक्टर आवंटन और एक आवेदन

के लिए स्मृति की रिहाई का प्रबंधन करता है आवंटित

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

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

जब आप एक्सई बंद करते हैं तो क्या होता है ?, क्या सीएलआर ऐप डोमेन को उतारने से पहले किसी भी जीसी दाएं चलाता है? (exe बंद), या ओएस करता है?

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