java - कैसे JVM स्टैक, ढेर और धागे भौतिक स्मृति या ऑपरेशन सिस्टम में मैप किए जाते हैं




c++ memory (2)

जो मुझे समझ में नहीं आता है कि चूंकि जेवीएम अनिवार्य रूप से एक सॉफ्टवेयर है, तो उन जेवीएम ढेर, ढेर और धागे भौतिक मशीन में कैसे मैप किए जाते हैं?

ढेर आभासी स्मृति का एक पूर्व आवंटित निरंतर क्षेत्र है। जैसे

 void* heap = malloc(Xmx); // get the maximum size.

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

 void* stack = malloc(Xss); // get the maximum stack size.

मूल धागे ओएस फीचर्स हैं जो जेवीएम स्पेस का हिस्सा नहीं हैं।

चूंकि जावा जेवीएम पर चलता है, लेकिन सी ++ नहीं करता है।

सी ++ को अभी भी एक रनटाइम पर्यावरण और पुस्तकालयों को शुरू करने की आवश्यकता है। अपने सी ++ रनटाइम या libc को हटाने का प्रयास करें और ये शुरू नहीं होंगे।

जावा के साथ तुलना, सी ++ रन-टाइम डेटा क्षेत्र कैसा दिखता है?

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

कैसे JVM ढेर, ढेर, रजिस्टर और धागे ऑपरेटिंग सिस्टम के लिए मैप किए जाते हैं? या मुझे पूछना चाहिए कि उन्हें भौतिक मशीन में कैसे मैप किया गया है?

फिर कोई जादू नहीं है। जेवीएम हीप मेमोरी का एक क्षेत्र है, एक जेवीएम स्टैक एक देशी स्टैक है जो सी + का उपयोग करता है, जेवीएम के रजिस्ट्रार देशी रजिस्टरों के समान ही हैं जो सी + उपयोग और जेवीएम थ्रेड वास्तव में मूल धागे हैं जो सी + उपयोग करता है ।

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

मुझे पूछना चाहिए कि उन्हें भौतिक मशीन में कैसे मैप किया गया है?

मूल रूप से एक से एक।

कंपाइलर पुस्तक (ड्रैगन पुस्तक) बताती है कि स्टैक पर मूल्य प्रकार बनाए जाते हैं, और संदर्भ प्रकार ढेर पर बनाए जाते हैं।

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

जावा रन-टाइम डेटा क्षेत्रों के बारे में अधिक जानकारी।

जो मुझे समझ में नहीं आता है कि चूंकि जेवीएम अनिवार्य रूप से एक सॉफ्टवेयर है, तो उन जेवीएम ढेर, ढेर और धागे भौतिक मशीन में कैसे मैप किए जाते हैं?

अगर कोई जावा और सी ++ के बीच उन अवधारणाओं की तुलना कर सकता है तो मैं इसकी सराहना करता हूं। चूंकि जावा जेवीएम पर चलता है, लेकिन सी ++ नहीं करता है।

इस सवाल को और सटीक बनाने के लिए, मैं निम्नलिखित जानना चाहता हूं:

  1. जावा के साथ तुलना, सी ++ रन-टाइम डेटा क्षेत्र कैसा दिखता है? एक तस्वीर सहायक होगी, मुझे ऊपर एक जेवीएम की तरह एक अच्छी तस्वीर नहीं मिल रही है।
  2. कैसे JVM ढेर, ढेर, रजिस्टर और धागे ऑपरेटिंग सिस्टम के लिए मैप किए जाते हैं? या मुझे पूछना चाहिए कि उन्हें भौतिक मशीन में कैसे मैप किया गया है?
  3. क्या यह सच है कि प्रत्येक जेवीएम धागे बस एक उपयोगकर्ता धागा है और किसी भी तरह से कर्नल में मैप किया जाता है? (उपयोगकर्ता थ्रेड बनाम कर्नेल थ्रेड)

अद्यतन : मैं एक प्रक्रिया की रनटाइम भौतिक स्मृति के लिए एक तस्वीर खींचता हूं।


जावा अनुप्रयोग चलाने के लिए जेवीएम (जावा वर्चुअल मशीन) रन-टाइम इंजन के रूप में कार्य करता है। JVM वह है जो वास्तव में जावा कोड में मौजूद मुख्य विधि को कॉल करता है। जेवीएम जेआरई (जावा रन पर्यावरण) का हिस्सा है।

जावा अनुप्रयोगों को वर्मा कहा जाता है (लिखें एक बार रन कहीं भी)। इसका अर्थ यह है कि एक प्रोग्रामर एक सिस्टम पर जावा कोड विकसित कर सकता है और किसी भी समायोजन के बिना इसे किसी भी अन्य जावा सक्षम सिस्टम पर चलाने की उम्मीद कर सकता है। JVM की वजह से यह सब संभव है। जब हम एक .java फ़ाइल संकलित करते हैं, तो एक फ़ाइल फ़ाइल के साथ एक .class फ़ाइल (बाइट-कोड शामिल है) जावा कंपाइलर द्वारा उत्पन्न होती है। जब हम इसे चलाते हैं तो यह .class फ़ाइल विभिन्न चरणों में जाती है। ये कदम पूरे JVM का वर्णन करते हैं।







runtime