परिचय

क्या जावा ऑब्जेक्ट में शामिल है:

सुपरक्लास में घोषित क्षेत्र?
सुपरक्लास में घोषित निजी क्षेत्र?
तरीकों?
सरणी तत्व?
सरणी की लंबाई?
एक और वस्तु (अपने आप में)?
हैश कोड?
प्रकार (अपने)?
नाम (अपना)?

इन (और अन्य) सवालों के जवाब कक्षा पुस्तकालय org.openjdk.jol का उपयोग करके प्राप्त किए जा सकते हैं, जो विशेष रूप से, हमें यह समझने की अनुमति देता है कि ऑब्जेक्ट एक मेमोरी क्षेत्र है:

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

ट्रेनिंग

यहाँ java.lang.instrument पैकेज के विवरण से विधि द्वारा विभिन्न प्रकार की वस्तुओं की स्मृति का मूल्यांकन करने के परिणाम हैं। ये परिणाम हमें ऊपर दिए गए अधिकांश सवालों के जवाब देने की अनुमति देते हैं।

निम्नलिखित चरणों को पूरा किया जाना चाहिए:

प्रीमियर विधि युक्त एक एजेंट वर्ग बनाएँ:
```
public static void premain(String, Instrumentation) {...} 
```
एजेंट वर्ग और सामग्री के साथ प्रकट फ़ाइल युक्त एक संग्रह बनाएँ:
```
 Premain-class: -- 
```
मेमोरी का मूल्यांकन करने के लिए एक निष्पादन योग्य वर्ग बनाएं।
वर्चुअल मशीन शुरू करते समय "-javaagent" पैरामीटर के साथ संग्रह निर्दिष्ट करें:
```
 java -javaagent:- -- 
```

चलो एक परीक्षण के मामले के साथ शुरू करते हैं। सादगी के लिए हम एक अनाम पैकेज का उपयोग करते हैं।

चरण 1. एक परीक्षण एजेंट वर्ग बनाएँ

 import java.lang.instrument.Instrumentation; public class A { public static void premain(String notUsedHere, Instrumentation i) { System.out.println("premain"); } }

हम संकलन करते हैं:

 javac A.java

चरण 2. एक m.txt मेनिफ़ेस्ट फ़ाइल बनाएँ:

 Premain-class: A

ध्यान दें: फ़ाइल की दूसरी पंक्ति EMPTY होनी चाहिए, जिसमें SPACES नहीं हो।

A. एज़र संग्रह बनाएँ:

 jar cmf m.txt A.jar A.class

चरण 3. एक परीक्षण निष्पादन योग्य वर्ग बनाएं

 public class M { public static void main(String[] notUsedHere) { //     System.out.println("main"); } }

हम संकलन करते हैं:

 javac M.java

चरण 4. प्रदर्शन

 java -javaagent:A.jar M

परिणाम:

 premain main

इंगित करता है कि एजेंट वर्ग का मुख्य तरीका पहले कहा जाता था, और फिर निष्पादन योग्य वर्ग की मुख्य विधि।

अब आवश्यक एजेंट वर्ग बनाएँ:

 import java.lang.instrument.Instrumentation; public class A { //      private static Instrumentation ins; public static void premain(String notUsedHere, Instrumentation i) { ins = i; } public static Instrumentation instrumentation() {return ins;} }

और निष्पादन योग्य वर्ग:

 class M { public static void main(String[] notUsedHere) { mem("Object", new Object()); } private static void mem(Object o, Object ref) { System.out.println(o + ": " + objectBytesEstimate(ref)); } private static long objectBytesEstimate(Object ref) { if (A.instrumentation() == null) { throw new RuntimeException("Not initialized instrumentation."); } return A.instrumentation().getObjectSize(ref); } }

विधि

 long getObjectSize(Object --)

निर्दिष्ट लिंक पर ऑब्जेक्ट द्वारा कब्जा की गई मेमोरी के आकार (बाइट्स की संख्या) का एक वर्गीकरण। यह ध्यान में रखना होगा कि परिणामी अनुमान किसी अन्य वर्चुअल मशीन के लिए भिन्न हो सकता है। Jdk-13 के मूल्यों को यहां सूचीबद्ध किया जाएगा।

हम बाहर ले:

 javac *.java jar cmf m.txt A.jar A.class java -javaagent:A.jar M

और हमें इसका परिणाम मिलता है:

 Object: 16

यह दिखाते हुए कि प्रकार की वस्तु का एक EMPTY ऑब्जेक्ट यहां रहता है (BY ASSESSMENT) 16 बाइट्स। इनमें से, 12 बाइट्स हेडर पर कब्जा कर लेते हैं, और अंत में 4 बाइट्स 8 बाइट्स की सीमा तक ऑब्जेक्ट की लंबाई को संरेखित करने के लिए कार्य करते हैं।

परिणाम

आगे के उदाहरणों में केवल कक्षा एम की मुख्य विधि में रखा कोड होगा। उन्हें प्रत्येक उदाहरण के लिए कमांड के साथ निष्पादित किया जाना चाहिए:

 javac M.java java -javaagent:A.jar M

ए-रेज़र को फिर से बनाना आवश्यक नहीं है।

उदाहरण के लिए, खेतों के बिना एक मनमाने प्रकार की वस्तु के स्मृति आकार का अनुमान लगाने के लिए, हम कोड को मुख्य विधि में रखते हैं:

 class C {}; mem("Empty", new C()); // Empty: 16

टिप्पणी में संकेतित परिणाम से पता चलता है कि खेतों के बिना एक वस्तु प्रकार की वस्तु के रूप में कई बाइट्स के रूप में रहती है।

आगे, कार्यक्रम का परिणाम:

 {class C {int a; } mem(1, new C());} // 1: 16 {class C {int a,b; } mem(2, new C());} // 2: 24 {class C {int a,b,c; } mem(3, new C());} // 3: 24 {class C {int a,b,c,d;} mem(4, new C());} // 4: 32

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

प्रत्येक लंबा क्षेत्र 8 बाइट्स है:

 {class C {long a; } mem(1, new C());} // 1: 24 {class C {long a,b; } mem(2, new C());} // 2: 32 {class C {long a,b,c;} mem(3, new C());} // 3: 40

प्रत्येक बूलियन फ़ील्ड में 1 बाइट लगती है (इस वीएम के लिए):

 {class C {boolean a; } mem(1, new C());} // 1: 16 {class C {boolean a,b; } mem(2, new C());} // 2: 16 {class C {boolean a,b,c; } mem(3, new C());} // 3: 16 {class C {boolean a,b,c,d; } mem(4, new C());} // 4: 16 {class C {boolean a,b,c,d,e;} mem(5, new C());} // 5: 24

प्रत्येक संदर्भ फ़ील्ड में 4 बाइट्स होते हैं (इस VM के लिए):

 {class C {Boolean a; } mem(1, new C());} // 1: 16 {class C {Integer a; } mem(1, new C());} // 1: 16 {class C {Long a; } mem(1, new C());} // 1: 16 {class C {C a; } mem(1, new C());} // 1: 16 {class C {Boolean a,b; } mem(2, new C());} // 2: 24 {class C {Integer a,b; } mem(2, new C());} // 2: 24 {class C {Long a,b; } mem(2, new C());} // 2: 24 {class C {C a,b; } mem(2, new C());} // 2: 24 {class C {Boolean a,b,c; } mem(3, new C());} // 3: 24 {class C {Integer a,b,c; } mem(3, new C());} // 3: 24 {class C {Long a,b,c; } mem(3, new C());} // 3: 24 {class C {C a,b,c; } mem(3, new C());} // 3: 24 {class C {Boolean a,b,c,d;} mem(4, new C());} // 4: 32 {class C {Integer a,b,c,d;} mem(4, new C());} // 4: 32 {class C {Long a,b,c,d;} mem(4, new C());} // 4: 32 {class C {C a,b,c,d;} mem(4, new C());} // 4: 32

एक स्ट्रिंग-प्रकार फ़ील्ड भी हर संदर्भ की तरह 4 बाइट्स लेता है:

 {class C {String a; } mem(" null", new C());} // null: 16 {class C {String a=""; } mem(" empty", new C());} // empty: 16 {class C {String a="A"; } mem("1-char", new C());} // 1-char: 16 {class C {String a="1234567";} mem("7-char", new C());} // 7-char: 16

एक सरणी संदर्भ फ़ील्ड भी 4 बाइट्स लेता है, जैसे हर संदर्भ एक:

 {class C {int[] a; } mem("null", new C());} // null: 16 {class C {int[] a = {}; } mem(" 0", new C());} // 0: 16 {class C {int[] a = new int[1]; } mem(" 1", new C());} // 1: 16 {class C {int[] a = new int[7]; } mem(" 7", new C());} // 7: 16 {class C {int[][] a = {}; } mem(" 00", new C());} // 00: 16 {class C {int[][] a = new int[1][1];} mem(" 11", new C());} // 11: 16 {class C {int[][] a = new int[7][7];} mem(" 77", new C());} // 77: 16

उपप्रकार वस्तु में सुपरक्लास में घोषित प्रत्येक क्षेत्र शामिल है, भले ही पहुंच संशोधक:

 {class S { } class C extends S {long a;} mem("0+1", new C());} // 0+1: 24 {class S {private long a;} class C extends S { } mem("1+0", new C());} // 1+0: 24

उप-प्रकार की वस्तु में सुपरक्लास में उसी नाम से घोषित एक क्षेत्र होता है जैसे उप-वर्ग में (तथाकथित - छिपा हुआ):

 {class S { } class C extends S {long a,b;} mem("0+2", new C());} // 0+2: 32 {class S {long a;} class C extends S {long a; } mem("1+1", new C());} // 1+1: 32

एक उपप्रकार ऑब्जेक्ट में प्रत्येक सुपरक्लासेस में प्रत्येक क्षेत्र को घोषित किया गया है:

 class U {private long a; } class S extends U {private long a; } class C extends S { long a; } mem("1+1+1", new C()); // 1+1+1: 40 class D { long a,b,c;} mem("0+0+3", new D()); // 0+0+3: 40

सरणियों की ओर मुड़ें। जैसा कि आप जानते हैं, एक सरणी एक विशेष प्रकार की वस्तु है जिसके तत्व स्वयं में होते हैं, इसलिए सरणी द्वारा कब्जा की गई मेमोरी का आकार तत्वों की संख्या के साथ बढ़ता है:

 {long[] a = new long[ 0]; mem(" 0", a);} // 0: 16 {long[] a = new long[ 1]; mem(" 1", a);} // 1: 24 {long[] a = new long[ 2]; mem(" 2", a);} // 2: 32 {long[] a = new long[ 3]; mem(" 3", a);} // 3: 40 {long[] a = new long[100]; mem("100", a);} // 100: 816

और लिंक की सरणी के लिए:

 {Long[] a = new Long[ 0]; mem(" 0", a);} // 0: 16 {Long[] a = new Long[ 1]; mem(" 1", a);} // 1: 24 {Long[] a = new Long[ 2]; mem(" 2", a);} // 2: 24 {Long[] a = new Long[ 3]; mem(" 3", a);} // 3: 32 {Long[] a = new Long[100]; mem("100", a);} // 100: 416

अब, जिज्ञासा से बाहर, हम विभिन्न प्रकारों की कई वस्तुओं के आकार की तुलना करते हैं:

 mem(" Object", new Object()); // Object: 16 mem(" String", new String("ABC")); // String: 24 mem(" Exception", new Exception()); // Exception: 40 mem(" int.class", int.class); // int.class: 112 mem(" int[].class", int[].class); // int[].class: 112 mem("Object.class", Object.class); // Object.class: 112 mem("System.class", System.class); // System.class: 160 mem("String.class", String.class); // String.class: 136

64-बिट प्रोसेसर पर अलग jdk के लिए समान:

                 jdk1.6.0_45 jdk1.7.0_80 jdk1.8.0_191 jdk-9 jdk-12 jdk-13
                 ----------- ----------- ------------ ------ ------ ---- -
       वस्तु: 16 16 16 16 16 16
       स्ट्रिंग: 32 24 24 24 24 24
    अपवाद: 32 32 32 40 40 40
    int.class: 104 88 104 112 104 112
  int []। वर्ग: ५ 5४ ५४४ ४ .० ११२ ११४ ११२ ११२
 Object.class: 600 560 496 112 104 112
 System.class: 624 560 496 144 152 160
 स्ट्रिंग.क्लास: 696 640 624 136 128 136

स्ट्रिंग आकार का अनुमान 24 बाइट्स है, हालांकि स्ट्रिंग वर्ग में कई स्थिर चर, स्थिर और गैर-स्थिर विधियां शामिल हैं। यह निस्संदेह वस्तु में स्थिर चर और कोड की अनुपस्थिति को इंगित करता है। किसी भी प्रकार की वस्तु के लिए भी यही सच है।

अंत में, एक अनुस्मारक: ऑब्जेक्ट के आकार पर सभी डेटा अनुमानित हैं और वे कुछ हद तक एक निष्पादन से दूसरे तक और निश्चित रूप से, विभिन्न आभासी मशीनों के लिए भिन्न हो सकते हैं।

जावा वस्तुओं के विभिन्न प्रकार के आकार