जावा ऑब्जेक्ट का आकार

क्या आप जानते हैं कि एक स्ट्रिंग कितनी मेमोरी में रहती है? इस प्रश्न के उत्तर मैंने नहीं सुने हैं, "मुझे नहीं पता" से लेकर "2 बाइट्स" स्ट्रिंग में वर्णों की संख्या तक है। " और फिर खाली स्ट्रिंग कितना लेती है? क्या आप जानते हैं कि वर्ग इंटेगर का एक उद्देश्य कब तक रहता है? और तीन इंटेगर फ़ील्ड्स के साथ आपकी खुद की क्लास ऑब्जेक्ट कितनी होगी? यह मजेदार है, लेकिन एक भी जावा प्रोग्रामर नहीं है जो मुझे पता था कि इन सवालों का जवाब दे सकता है ... हां, हम में से अधिकांश को इसकी आवश्यकता नहीं है और वास्तविक जावा परियोजनाओं में कोई भी इसके बारे में नहीं सोचेगा। लेकिन यह है, आखिरकार, उस कार के इंजन विस्थापन का पता कैसे नहीं चलेगा जिस पर आप ड्राइव करते हैं। आप एक महान ड्राइवर हो सकते हैं और यह भी संदेह नहीं है कि आपकी कार पर 2.4 या 1.6 नंबर का क्या मतलब है। लेकिन मुझे यकीन है कि बहुत कम लोग हैं जो इन नंबरों के अर्थ से परिचित नहीं हैं। तो जावा प्रोग्रामर अपने टूल के इस हिस्से के बारे में इतना कम क्यों जानते हैं?

पूर्णांक बनाम इंट

हम सभी जानते हैं कि जावा में - सब कुछ एक वस्तु है। सिवाय, शायद, आदिम और वस्तुओं से खुद को जोड़ता है। आइए दो विशिष्ट स्थितियों को देखें:

//  int a = 300; //  Integer b = 301; 

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

 sizeOf(int) 

फिर दूसरे में:

 sizeOf(reference) + sizeOf(Integer) 

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

वस्तु से क्या बनता है?

खपत की गई स्मृति की मात्रा निर्धारित करने से पहले, आपको यह पता लगाना चाहिए कि प्रत्येक वस्तु के लिए जेवीएम क्या है:

• वस्तु शीर्षक
• आदिम प्रकारों के लिए मेमोरी;
• संदर्भ प्रकारों के लिए मेमोरी;
• ऑफसेट / संरेखण - वास्तव में, ये कुछ अप्रयुक्त बाइट्स होते हैं जिन्हें ऑब्जेक्ट के डेटा के बाद रखा जाता है। ऐसा इसलिए किया जाता है ताकि मेमोरी एड्रेस हमेशा मेमोरी से रीडिंग को तेज करने के लिए मशीन वर्ड का एक मल्टीपल हो, किसी ऑब्जेक्ट के लिए पॉइंटर के लिए बिट्स की संख्या कम करने के लिए + संभवतः मेमोरी फ्रैगमेंटेशन को कम करने के लिए। यह भी ध्यान देने योग्य है कि जावा में किसी भी वस्तु का आकार 8 बाइट्स से अधिक होता है!

ऑब्जेक्ट शीर्षक संरचना

कक्षा के प्रत्येक उदाहरण में एक शीर्षक होता है। अधिकांश जेवीएम (हॉटस्पॉट, ओपन जेवीएम) के लिए प्रत्येक शीर्षक में दो मशीन शब्द होते हैं। यदि हम 32-बिट सिस्टम के बारे में बात कर रहे हैं, तो हेडर का आकार 8 बाइट्स है, अगर हम 64-बिट सिस्टम के बारे में बात कर रहे हैं, तो क्रमशः 16 बाइट्स। प्रत्येक शीर्षक में निम्नलिखित जानकारी हो सकती है:

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

जावा विनिर्देशन

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

पूर्णांक और स्ट्रिंग

तो, आइए गणना करने की कोशिश करें कि हमारे 32-बिट हॉटस्पॉट जेवीएम में इंटेगर वर्ग की वस्तु कितनी अधिक होगी। ऐसा करने के लिए, आपको खुद को कक्षा में देखने की आवश्यकता होगी, हम उन सभी क्षेत्रों में रुचि रखते हैं जिन्हें स्थिर घोषित नहीं किया गया है। इनसे हम केवल एक चीज देखते हैं - इंट वैल्यू। अब, उपरोक्त जानकारी के आधार पर, हम प्राप्त करते हैं:

 : 8   int: 4     8 : 4  : 16  

अब लाइन क्लास देखें:

  private final char value[]; private final int offset; private final int count; private int hash; 

और आकार की गणना करें:

 : 8   int: 4  * 3 == 12      : 4  : 24  

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

 new String() : 8   int: 4  * 3 == 12      : 4  : 24  new char[1] : 8  + 4     == 12   char: 2  * 1 == 2     8 : 2  : 16  , new String("a") == 40  

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

लिंक का आकार

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

फील्ड ग्रुपिंग

यह भी ध्यान दिया जाना चाहिए कि जेवीएम ऑब्जेक्ट के क्षेत्रों को पूर्व-समूहित करता है। इसका मतलब यह है कि वर्ग के सभी क्षेत्रों को एक निश्चित क्रम में स्मृति में रखा जाता है, और घोषित नहीं किया जाता है। समूहीकरण क्रम इस तरह दिखता है:

• 1. 8 बाइट प्रकार (डबल और लंबी)
• 2. 4 बाइट प्रकार (इंट और फ्लोट)
• 3. 2-बाइट प्रकार (लघु और चार)
• 4. एक बाइट प्रकार ( बूलियन और बाइट)
• 5. संदर्भ चर

यह सब क्यों?

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

निष्कर्ष

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