如何计算java内存大小--谁吃了对象引用的16byte？

public class ResidenceRulesDO {

    /**
     * This property corresponds to db column <tt>BEGIN_CODE</tt>.
     */
    private long              beginCode;

    /**
     * This property corresponds to db column <tt>END_CODE</tt>.
     */
    private long              endCode;

    /**
     * This property corresponds to db column <tt>NATION</tt>.
     */
    private String            nation;

    /**
     * This property corresponds to db column <tt>PROVINCE</tt>.
     */
    private String            province;

    /**
     * This property corresponds to db column <tt>CITY</tt>.
     */
    private String            city;

    /**
     * This property corresponds to db column <tt>MEMO</tt>.
     */
    private String            memo;

    /**
     * This property corresponds to db column <tt>GMT_CREATE</tt>.
     */
    private Date              gmtCreate;

    /**
     * This property corresponds to db column <tt>GMT_MODIFIED</tt>.
     */
    private Date              gmtModified;

    //-----------------------setter/getter--------------------------

    public long getBeginCode() {
        return beginCode;
    }

    public void setBeginCode(long beginCode) {
        this.beginCode = beginCode;
    }

    public long getEndCode() {
        return endCode;
    }

    public void setEndCode(long endCode) {
        this.endCode = endCode;
    }

    public String getNation() {
        return nation;
    }

    public void setNation(String nation) {
        this.nation = nation;
    }

    public String getProvince() {
        return province;
    }

    public void setProvince(String province) {
        this.province = province;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getMemo() {
        return memo;
    }

    public void setMemo(String memo) {
        this.memo = memo;
    }

    public Date getGmtCreate() {
        return gmtCreate;
    }

    public void setGmtCreate(Date gmtCreate) {
        this.gmtCreate = gmtCreate;
    }

    public Date getGmtModified() {
        return gmtModified;
    }

    public void setGmtModified(Date gmtModified) {
        this.gmtModified = gmtModified;
    }

}

 

这样一个对象，如何计算内存大小？

1.只new出一个ResidenceRulesDO 对象

a.通过规则计算

一个空对象占8个字节，一个引用占4个字节，一个long占8个字节

ResidenceRulesDO对象（8）+ 2个long型（8*2）+4个String引用（4*4）+2个Date引用（2*4）=48bytes

b.通过程序计算

此程序来源于http://www.javaworld.com/javaworld/javatips/jw-javatip130.html?page=1

 

import java.util.Date;

public class Sizeof {
    public static void main(String[] args) throws Exception {
        // Warm up all classes/methods we will use
        runGC();
        usedMemory();
        // Array to keep strong references to allocated objects
        final int count = 100000;
        Object[] objects = new Object[count];
        long heap1 = 0;
        // Allocate count+1 objects, discard the first one
        for (int i = -1; i < count; ++i) {
            ResidenceRulesDO object = null;
            // Instantiate your data here and assign it to object
            object = new ResidenceRulesDO();
//            object.setBeginCode(new Long(i));
//            object.setEndCode(new Long(i));
//            object.setProvince(new String());
//            object.setCity(new String());
//            object.setNation(new String());
//            object.setMemo(new String());
//            object.setGmtCreate(new Date());
//            object.setGmtModified(new Date());
            //object = new Integer (i);
            //object = new Long (i);
            //object = new String ();
            //object = new byte [128][1]
            if (i >= 0)
                objects[i] = object;
            else {
                object = null; // Discard the warm up object
                runGC();
                heap1 = usedMemory(); // Take a before heap snapshot
            }
        }
        runGC();
        long heap2 = usedMemory(); // Take an after heap snapshot:

        final int size = Math.round(((float) (heap2 - heap1)) / count);
        System.out.println("'before' heap: " + heap1 + ", 'after' heap: " + heap2);
        System.out.println("heap delta: " + (heap2 - heap1) + ", {" + objects[0].getClass()
                           + "} size = " + size + " bytes");

        for (int i = 0; i < count; ++i) {
            objects[i] = null;
        }

        objects = null;
    }

    private static void runGC() throws Exception {
        // It helps to call Runtime.gc()
        // using several method calls:
        for (int r = 0; r < 4; ++r)
            _runGC();
    }

    private static void _runGC() throws Exception {
        long usedMem1 = usedMemory(), usedMem2 = Long.MAX_VALUE;
        for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
            s_runtime.runFinalization();
            s_runtime.gc();
            Thread.currentThread().yield();

            usedMem2 = usedMem1;
            usedMem1 = usedMemory();
        }
    }

    private static long usedMemory() {
        return s_runtime.totalMemory() - s_runtime.freeMemory();
    }

    private static final Runtime s_runtime = Runtime.getRuntime();
} // End of class

 

输出结果：

 

'before' heap: 668176, 'after' heap: 5466520
heap delta: 4798344, {class com.alipay.cif.core.dal.dataobject.ResidenceRulesDO} size = 48 bytes

 

两者计算相同。

 

 

 

2.如果是赋值的ResidenceRulesDO呢？

比如此对象为

            object = new ResidenceRulesDO();
            object.setBeginCode(new Long(i));
            object.setEndCode(new Long(i));
            object.setProvince(new String());
            object.setCity(new String());
            object.setNation(new String());
            object.setMemo(new String());
            object.setGmtCreate(new Date());
            object.setGmtModified(new Date());

 

 a.通过算法计算

此前算出来的空对象（48）+2个Long值（16*2）+4个String（40*4）+2个Date（24*2）=288

 

b.通过程序计算

import java.util.Date;

public class Sizeof {
    public static void main(String[] args) throws Exception {
        // Warm up all classes/methods we will use
        runGC();
        usedMemory();
        // Array to keep strong references to allocated objects
        final int count = 100000;
        Object[] objects = new Object[count];
        long heap1 = 0;
        // Allocate count+1 objects, discard the first one
        for (int i = -1; i < count; ++i) {
            ResidenceRulesDO object = null;
            // Instantiate your data here and assign it to object
            object = new ResidenceRulesDO();
            object.setBeginCode(new Long(i));
            object.setEndCode(new Long(i));
            object.setProvince(new String());
            object.setCity(new String());
            object.setNation(new String());
            object.setMemo(new String());
            object.setGmtCreate(new Date());
            object.setGmtModified(new Date());
            //object = new Integer (i);
            //object = new Long (i);
            //object = new String ();
            //object = new byte [128][1]
            if (i >= 0)
                objects[i] = object;
            else {
                object = null; // Discard the warm up object
                runGC();
                heap1 = usedMemory(); // Take a before heap snapshot
            }
        }
        runGC();
        long heap2 = usedMemory(); // Take an after heap snapshot:

        final int size = Math.round(((float) (heap2 - heap1)) / count);
        System.out.println("'before' heap: " + heap1 + ", 'after' heap: " + heap2);
        System.out.println("heap delta: " + (heap2 - heap1) + ", {" + objects[0].getClass()
                           + "} size = " + size + " bytes");

        for (int i = 0; i < count; ++i) {
            objects[i] = null;
        }

        objects = null;
    }

    private static void runGC() throws Exception {
        // It helps to call Runtime.gc()
        // using several method calls:
        for (int r = 0; r < 4; ++r)
            _runGC();
    }

    private static void _runGC() throws Exception {
        long usedMem1 = usedMemory(), usedMem2 = Long.MAX_VALUE;
        for (int i = 0; (usedMem1 < usedMem2) && (i < 500); ++i) {
            s_runtime.runFinalization();
            s_runtime.gc();
            Thread.currentThread().yield();

            usedMem2 = usedMem1;
            usedMem1 = usedMemory();
        }
    }

    private static long usedMemory() {
        return s_runtime.totalMemory() - s_runtime.freeMemory();
    }

    private static final Runtime s_runtime = Runtime.getRuntime();
} // End of class

 

输出：

'before' heap: 669120, 'after' heap: 26267784
heap delta: 25598664, {class com.alipay.cif.core.dal.dataobject.ResidenceRulesDO} size = 256 bytes

 

 

 两种算法的差别在哪里呢？

经过程序的调试，2个Long型设置与不设置值，都不影响整个对象的内存的大小，

正好288-256=2*16（2个Long）一致

 

为什么在对象中，引用到的Long对象不占空间呢？而单独计算Long对象却要16个byte？与常量池有关系吗？路漫漫其修远，还需慢慢探索啊！ 

评论

1 楼 teasp 2013-05-07  

哪有两个Long啊？分明是两个long，这是原始类型，它们所占空间是固定的，你没给它赋值，它也有个0值啊。