जावा में ऑब्जेक्ट के आकार की गणना

Question

मैं रिकॉर्ड करना चाहता हूं कि एक वस्तु के लिए एक वस्तु (बाइट्स, उम्मीद है कि) एक वस्तु के लिए कितनी मेमोरी लेती है (मैं डेटा संरचनाओं के आकार की तुलना कर रहा हूं) और ऐसा लगता है कि ऐसा करने के लिए कोई तरीका नहीं है जावा में माना जाता है कि, सी/सी ++ में sizeOf() विधि है, लेकिन यह जावा में कोई भी नहीं है। मैंने ऑब्जेक्ट बनाने से पहले और बाद में Runtime.getRuntime().freeMemory() के साथ JVM में मुफ्त मेमोरी रिकॉर्ड करने का प्रयास किया और फिर अंतर रिकॉर्ड किया, लेकिन यह केवल 0 या 131304, और संरचना में तत्वों की संख्या के बावजूद, बीच में कुछ भी नहीं देगा। कृपया मदद करें!

http://docs.oracle.com/javase/7/docs/api/java/lang/instrument/Instrumentation.html

यह एक विधि है कि वस्तु के आकार के कार्यान्वयन विशिष्ट सन्निकटन है, साथ ही भूमि के ऊपर वस्तु के साथ जुड़े पाने के लिए इस्तेमाल किया जा सकता है:

Answer 1

आप java.lang.instrumentation पैकेज का उपयोग कर सकते हैं।

जवाब यह है कि सेर्गेई जुड़ा हुआ एक महान उदाहरण है, जो मैं यहाँ repost हूँ है, लेकिन आप पहले से ही होना चाहिए उसकी टिप्पणी से देखा:

import java.lang.instrument.Instrumentation; 

public class ObjectSizeFetcher { 
    private static Instrumentation instrumentation; 

    public static void premain(String args, Instrumentation inst) { 
     instrumentation = inst; 
    } 

    public static long getObjectSize(Object o) { 
     return instrumentation.getObjectSize(o); 
    } 
} 

उपयोग getObjectSize:

public class C { 
    private int x; 
    private int y; 

    public static void main(String [] args) { 
     System.out.println(ObjectSizeFetcher.getObjectSize(new C())); 
    } 
} 

स्रोत

In Java, what is the best way to determine the size of an object?

Answer 2

एक गूगल: उदाहरण के लिए "जावा आकार" की खोज के परिणामस्वरूप javaworld पर Java sizeof के बारे में एक अच्छा लेख हुआ। असल में, एक दिलचस्प पढ़ा।

अपने प्रश्न का उत्तर देने के लिए, "sizeof()" के बराबर जावा नहीं है, लेकिन लेख आपके तत्काल वर्गों के बाइट आकार के बारे में कुछ तरीकों का वर्णन करता है।

Answer 3

https://github.com/DimitrisAndreou/memory-measurer में देखें 0 अमरूद इसे आंतरिक रूप से उपयोग करता है, और ऑब्जेक्टग्राफमेजर विशेष रूप से बिना किसी विशेष कमांड लाइन तर्क के आउट ऑफ़ द बॉक्स का उपयोग करने के लिए सीधा है।  

import objectexplorer.ObjectGraphMeasurer; 

public class Measurer { 

    public static void main(String[] args) { 
    Set<Integer> hashset = new HashSet<Integer>(); 
    Random random = new Random(); 
    int n = 10000; 
    for (int i = 1; i <= n; i++) { 
     hashset.add(random.nextInt()); 
    } 
    System.out.println(ObjectGraphMeasurer.measure(hashset)); 
    } 
} 

Answer 4

java.lang.instrument.Instrumentation वर्ग एक जावा वस्तु के आकार पाने के लिए एक अच्छा तरीका प्रदान करता है, लेकिन यह एक premain को परिभाषित करने और एक जावा एजेंट के साथ अपने कार्यक्रम चलाने की आवश्यकता है। यह बहुत उबाऊ है जब आपको किसी एजेंट की आवश्यकता नहीं होती है और फिर आपको अपने आवेदन के लिए डमी जार एजेंट प्रदान करना होगा।

तो मुझे sun.misc से Unsafe कक्षा का उपयोग करके एक वैकल्पिक समाधान मिला। इसलिए, प्रोसेसर आर्किटेक्चर के अनुसार ऑब्जेक्ट हेप संरेखण पर विचार करना और अधिकतम फ़ील्ड ऑफसेट की गणना करना, आप जावा ऑब्जेक्ट के आकार को माप सकते हैं। नीचे दिए गए उदाहरण में sun.misc.Unsafe ऑब्जेक्ट का संदर्भ प्राप्त करने के लिए मैं एक सहायक वर्ग UtilUnsafe का उपयोग करता हूं।

private static final int NR_BITS = Integer.valueOf(System.getProperty("sun.arch.data.model")); 
private static final int BYTE = 8; 
private static final int WORD = NR_BITS/BYTE; 
private static final int MIN_SIZE = 16; 

public static int sizeOf(Class src){ 
    // 
    // Get the instance fields of src class 
    // 
    List<Field> instanceFields = new LinkedList<Field>(); 
    do{ 
     if(src == Object.class) return MIN_SIZE; 
     for (Field f : src.getDeclaredFields()) { 
      if((f.getModifiers() & Modifier.STATIC) == 0){ 
       instanceFields.add(f); 
      } 
     } 
     src = src.getSuperclass(); 
    }while(instanceFields.isEmpty()); 
    // 
    // Get the field with the maximum offset 
    // 
    long maxOffset = 0; 
    for (Field f : instanceFields) { 
     long offset = UtilUnsafe.UNSAFE.objectFieldOffset(f); 
     if(offset > maxOffset) maxOffset = offset; 
    } 
    return (((int)maxOffset/WORD) + 1)*WORD; 
} 
class UtilUnsafe { 
    public static final sun.misc.Unsafe UNSAFE; 

    static { 
     Object theUnsafe = null; 
     Exception exception = null; 
     try { 
      Class<?> uc = Class.forName("sun.misc.Unsafe"); 
      Field f = uc.getDeclaredField("theUnsafe"); 
      f.setAccessible(true); 
      theUnsafe = f.get(uc); 
     } catch (Exception e) { exception = e; } 
     UNSAFE = (sun.misc.Unsafe) theUnsafe; 
     if (UNSAFE == null) throw new Error("Could not obtain access to sun.misc.Unsafe", exception); 
    } 
    private UtilUnsafe() { } 
}