> 作者：threedayman
> 
> 來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/1361 "恆生LIGHT雲社群")

以下內容基於HotSpot虛擬機器進行講解驗證。

## 理論知識

物件在堆記憶體中的儲存佈局可以劃分為三個部分：物件頭（Header）、例項資料（Instance Data）和對齊填充（Padding）。

物件頭中有兩類資訊

- 執行時資料：雜湊碼、GC分代年齡、鎖狀態標誌、執行緒持有的鎖、偏向執行緒ID、偏向時間戳等。
- 型別指標：物件指向它型別後設資料的指標，虛擬機器透過這個指標來確定該物件是哪個類的例項。

例項資料

- 物件儲存的有效資訊，即我們在程式程式碼中定義的各種型別的欄位內容。

對齊填充

- HotSpot虛擬機器的自動記憶體管理系統要求物件起始地址必須是8位元組的整數倍，如果物件佔用空間不是8個位元組的整數倍，就需要透過對齊填充來補全。

物件佔用大小受JVM引數UseCompressedOops的影響，64位作業系統，開啟時物件頭大小為12bytes，關閉壓縮指標是物件頭大小位16bytes。

## 實踐檢驗

透過Instrumentation的getObjectSize方法去測量物件佔用大小。具體程式碼如下

```
package org.example;

import java.lang.instrument.Instrumentation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashSet;
import java.util.Set;

public class SizeOfObject {
    static Instrumentation inst;

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

/**
     * 直接計算當前物件佔用空間大小，包括當前類及超類的基本型別例項欄位大小、<br>
     * 引用型別例項欄位引用大小、例項基本型別陣列總佔用空間、例項引用型別陣列引用本身佔用空間大小;<br>
     * 但是不包括超類繼承下來的和當前類宣告的例項引用欄位的物件本身的大小、例項引用陣列引用的物件本身的大小 <br>
     *
     * @param obj
     * @return
     */
    public static long sizeOf(Object obj) {
        return inst.getObjectSize(obj);
    }

/**
     * 遞迴計算當前物件佔用空間總大小，包括當前類和超類的例項欄位大小以及例項欄位引用物件大小
     *
     * @param objP
     * @return
     * @throws IllegalAccessException
     */
    public static long fullSizeOf(Object objP) throws IllegalAccessException {
        Set<object> visited = new HashSet<object>();
        Deque<object> toBeQueue = new ArrayDeque<>();
        toBeQueue.add(objP);
        long size = 0L;
        while (toBeQueue.size() > 0) {
            Object obj = toBeQueue.poll();
            //sizeOf的時候已經計基本型別和引用的長度，包括陣列
            size += skipObject(visited, obj) ? 0L : sizeOf(obj);
            Class> tmpObjClass = obj.getClass();
            if (tmpObjClass.isArray()) {
                //[I , [F 基本型別名字長度是2
                if (tmpObjClass.getName().length() > 2) {
                    for (int i = 0, len = Array.getLength(obj); i < len; i++) {
                        Object tmp = Array.get(obj, i);
                        if (tmp != null) {
                            //非基本型別需要深度遍歷其物件
                            toBeQueue.add(Array.get(obj, i));
                        }
                    }
                }
            } else {
                while (tmpObjClass != null) {
                    Field[] fields = tmpObjClass.getDeclaredFields();
                    for (Field field : fields) {
                        if (Modifier.isStatic(field.getModifiers())   //靜態不計
                                || field.getType().isPrimitive()) {    //基本型別不重複計
                            continue;
                        }

field.setAccessible(true);
                        Object fieldValue = field.get(obj);
                        if (fieldValue == null) {
                            continue;
                        }
                        toBeQueue.add(fieldValue);
                    }
                    tmpObjClass = tmpObjClass.getSuperclass();
                }
            }
        }
        return size;
    }

/**
     * String.intern的物件不計；計算過的不計，也避免死迴圈
     *
     * @param visited
     * @param obj
     * @return
     */
    static boolean skipObject(Set<object> visited, Object obj) {
        if (obj instanceof String && obj == ((String) obj).intern()) {
            return true;
        }
        return visited.contains(obj);
    }
}
```

測試物件大小程式碼

```
package org.example;

import static org.example.SizeOfObject.fullSizeOf;
import static org.example.SizeOfObject.sizeOf;

public class SizeOfObjectTest {

/**
     *  -XX:+UseCompressedOops: Header 12  Padding 4= 16
     *  -XX:-UseCompressedOops: Header 16 = 24
     */
    static class A1 {
    }
    /**
     * -XX:+UseCompressedOops: Header 12 + Instance Data 4 = 16
     * -XX:-UseCompressedOops: Header 16 + Instance Data 4 + Padding 4 = 24
     */
    static class A {
        int a;
    }

/**
     * -XX:+UseCompressedOops: Header 12 + Instance Data 4 + 4 + padding 4 = 24
     * -XX:-UseCompressedOops: Header 16 + Instance Data 4 + 4 = 24
     */
    static class B {
        int a;
        int b;
    }

/**
     * -XX:+UseCompressedOops: Header 12 + 4 + 4 + padding/4 = 24
     * -XX:-UseCompressedOops:Header 16 + 8 + 4 + padding/4 = 32
     */
    static class B2 {
        int b2a;
        Integer b2b;
    }

/**
     * 不考慮物件頭：
     * 4 + 4 + 4 * 3 + 3 * sizeOf(B)
     */
    static class C extends A {
        int ba;
        B[] as = new B[3];

C() {
            for (int i = 0; i < as.length; i++) {
                as[i] = new B();
            }
        }
    }

static class D extends B {
        int da;
        Integer[] di = new Integer[3];
    }

/**
     * 會算上A的例項欄位
     */
    static class E extends A {
        int ea;
        int eb;
    }

public static void main(String[] args) throws IllegalAccessException {
        System.out.println("sizeOf(new A1())=" + sizeOf(new A1()));
        System.out.println("sizeOf(new A())=" + sizeOf(new A()));
        System.out.println("sizeOf(new B())=" + sizeOf(new B()));
        System.out.println("sizeOf(new B2())=" + sizeOf(new B2()));
        System.out.println("sizeOf(new B[3])=" + sizeOf(new B[3]));
        System.out.println("sizeOf(new C())=" + sizeOf(new C()));
        System.out.println("fullSizeOf(new C())=" + fullSizeOf(new C()));
        System.out.println("sizeOf(new D())=" + sizeOf(new D()));
        System.out.println("fullSizeOf(new D())=" + fullSizeOf(new D()));
        System.out.println("sizeOf(new int[3])=" + sizeOf(new int[3]));
        System.out.println("sizeOf(new Integer(1)=" + sizeOf(new Integer(1)));
        System.out.println("sizeOf(new Integer[0])=" + sizeOf(new Integer[0]));
        System.out.println("sizeOf(new Integer[1])=" + sizeOf(new Integer[1]));
        System.out.println("sizeOf(new Integer[2])=" + sizeOf(new Integer[2]));
        System.out.println("sizeOf(new Integer[3])=" + sizeOf(new Integer[3]));
        System.out.println("sizeOf(new Integer[4])=" + sizeOf(new Integer[4]));
        System.out.println("sizeOf(new A[3])=" + sizeOf(new A[3]));
        System.out.println("sizeOf(new E())=" + sizeOf(new E()));
    }
}
```

打包外掛中增加以下配置

```
<plugin>
  <artifactid>maven-jar-plugin</artifactid>
  <version>3.0.2</version>
  <configuration>
	<finalname>test</finalname>
	<archive>
	  <manifestentries>
		<premain-class>org.example.SizeOfObject</premain-class>
		<boot-class-path></boot-class-path>
		<can-redefine-classes>false</can-redefine-classes>
		<main-class>org.example.SizeOfObjectTest</main-class>
	  </manifestentries>
	  <addmavendescriptor>false</addmavendescriptor>
	</archive>
  </configuration>
</plugin>
```

配置指定的main方法入口類、agent增強類入口。預設情況下 開啟了指標壓縮。

```
D:\ideaproject\size-agent\target>java -javaagent:test.jar -jar test.jar
sizeOf(new A1())=16
sizeOf(new A())=16
sizeOf(new B())=24
sizeOf(new B2())=24
sizeOf(new B[3])=32
sizeOf(new C())=24
fullSizeOf(new C())=128
sizeOf(new D())=32
fullSizeOf(new D())=64
sizeOf(new int[3])=32
sizeOf(new Integer(1)=16
sizeOf(new Integer[0])=16
sizeOf(new Integer[1])=24
sizeOf(new Integer[2])=24
sizeOf(new Integer[3])=32
sizeOf(new Integer[4])=32
sizeOf(new A[3])=32
sizeOf(new E())=24
```

關閉指標壓縮

```
D:\ideaproject\size-agent\target>java -javaagent:test.jar -XX:-UseCompressedOops -jar test.jar
sizeOf(new A1())=16
sizeOf(new A())=24
sizeOf(new B())=24
sizeOf(new B2())=32
sizeOf(new B[3])=48
sizeOf(new C())=40
fullSizeOf(new C())=160
sizeOf(new D())=40
fullSizeOf(new D())=88
sizeOf(new int[3])=40
sizeOf(new Integer(1)=24
sizeOf(new Integer[0])=24
sizeOf(new Integer[1])=32
sizeOf(new Integer[2])=40
sizeOf(new Integer[3])=48
sizeOf(new Integer[4])=56
sizeOf(new A[3])=48
sizeOf(new E())=32
```

大家還可以根據自己想要了解的情況去更改上述程式碼，用來驗證自己的理論知識是否正確。

參考

《深入理解java虛擬機器》

[https://www.iteye.com/blog/yueyemaitian-2033046](https://www.iteye.com/blog/yueyemaitian-2033046)</object></object></object></object>

【HotSpot】一個java物件佔多少空間

相關文章