摘要：一個對象內存有多大為什么想知道這個，自以為很重要，其實。參考鏈接對象解析不得不了解的對象頭從開始在位系統上會默認開啟壓縮指針研究位引用指針壓縮技術

為什么想知道這個，自以為很重要，其實 just for fun =。=

jdk: java 官網上下載的，HotSpot 虛擬機

java version "1.8.0_121"
Java(TM) SE Runtime Environment (build 1.8.0_121-b13)
Java HotSpot(TM) 64-Bit Server VM (build 25.121-b13, mixed mode)

使用的方法： Instrumentation 參考的是 一個對象占用多少字節？

確認編譯時是 32 位還是 64 位，對測試結果有影響。x86 為 32 位， amd64 為 64 位，其余我不知道

System.out.println(System.getProperty("os.arch"));

SizeOfObject.java 直接從上面鏈接上拷貝

編譯這個類，得到 .class 文件

在包名路徑下執行一下命令進行打包（注意修改相應的包名）：

jar cvfm SizeOfObject.jar manifest.mf org/seal_de/SizeOfObject.class

其中 manifest.mf 清單信息為： PreMain-Class: org.seal_de.SizeOfObject

PS: 如果在打包好的 jar 包中，META-INF/MANIFEST.MF 沒有 PreMain-Class 屬性，添加上去即可

在運行測試程序的時候，添加 vm 參數

-javaagent:{jar包路徑}SizeOfObject.jar

測試 int, Object, 引用的大小。其余類型測試都類似

public class MemoryTest {
    /**
     * -javaagent:{jar包路徑}SizeOfObject.jar -XX:+UseCompressedOops
     * 使用指針壓縮，在一定情況下64位HotSpot jvm默認指針壓縮
     *
     *Output:
     *amd64
     *Object:                              16
     *    
     *include one int:                     16
     *include two int:                     24
     *include three int:                   24
     *
     *include one object:                  16
     *include one object:                  24
     */
    static void test1() {
        System.out.println(System.getProperty("os.arch"));
        System.out.printf("%-30s%9d
", "Object:", SizeOfObject.sizeOf(new Object()));
        System.out.println();
        System.out.printf("%-30s%9d
", "include one int:", SizeOfObject.sizeOf(new IntegerTestOne()));
        System.out.printf("%-30s%9d
", "include two int:", SizeOfObject.sizeOf(new IntegerTestTwo()));
        System.out.printf("%-30s%9d
", "include three int:", SizeOfObject.sizeOf(new IntegerTestThree()));
        System.out.println();
        System.out.printf("%-30s%9d
", "include one object:", SizeOfObject.sizeOf(new ReferenceTestOne()));
        System.out.printf("%-30s%9d
", "include one object:", SizeOfObject.sizeOf(new ReferenceTestTwo()));
    }

    /**
     * -javaagent:{jar包路徑}SizeOfObject.jar -XX:-UseCompressedOops
     * 不使用指針壓縮
     *
     *Output:
     *amd64
     *Object:                              16
     *
     *include one int:                     24
     *include two int:                     24
     *include three int:                   32
     *
     *include one object:                  24
     *include one object:                  32
     */
    static void test2() {
        System.out.println(System.getProperty("os.arch"));
        System.out.printf("%-30s%9d
", "Object:", SizeOfObject.sizeOf(new Object()));
        System.out.println();
        System.out.printf("%-30s%9d
", "include one int:", SizeOfObject.sizeOf(new IntegerTestOne()));
        System.out.printf("%-30s%9d
", "include two int:", SizeOfObject.sizeOf(new IntegerTestTwo()));
        System.out.printf("%-30s%9d
", "include three int:", SizeOfObject.sizeOf(new IntegerTestThree()));
        System.out.println();
        System.out.printf("%-30s%9d
", "include one object:", SizeOfObject.sizeOf(new ReferenceTestOne()));
        System.out.printf("%-30s%9d
", "include one object:", SizeOfObject.sizeOf(new ReferenceTestTwo()));
    }

    public static void main(String[] args) {
        test2();
    }

    static class IntegerTestOne {
        private int i1 = 1;
    }

    static class IntegerTestTwo {
        private int i1 = 1;
        private int i2 = 1;
    }

    static class IntegerTestThree {
        private int i1 = 1;
        private int i2 = 1;
        private int i3 = 1;
    }

    static class ReferenceTestOne {
        private Object o1 = new Object();
    }

    static class ReferenceTestTwo {
        private Object o1 = new Object();
        private Object o2 = new Object();
    }
}

對象內存 = 對象頭 + 類型指針 + 對齊填充

對象頭不參與指針壓縮，并且 32 位時為 4 個字節，64 位時為 8 個字節

類型指針參與指針壓縮，并且 32 位時為 4 個字節，64 位時為 8 個字節；指針壓縮時 64 位為 4 個字節

對齊填充，由于 jvm 設計內存要為 8 字節的整數倍，所以不足的需要填充。如 對象頭和類型指針一共 12 字節，填充后為 16 字節，填充了 4 個字節

其中 (8 + 8) 為對象頭和類型指針的字節數

public class MemoryStaticTest {
    /**
     * -javaagent:{jar包路徑}SizeOfObject.jar
     * 使用指針壓縮，在一定情況下64位HotSpot jvm默認指針壓縮
     *
     * Output:
     * amd64    +UseCompressedOops
     * StaticTest:                          16
     * Integer:                             16
     * StaticReferenceTest:                 16
     *
     * @param args
     */
    public static void main(String[] args) {
        System.out.println(System.getProperty("os.arch") + "    +UseCompressedOops");
        System.out.printf("%-30s%9d
", "StaticTest:", SizeOfObject.sizeOf(new StaticTest()));
        System.out.printf("%-30s%9d
", "Integer:", SizeOfObject.sizeOf(new Integer(1)));
        System.out.printf("%-30s%9d
", "StaticReferenceTest:", SizeOfObject.sizeOf(new StaticReferenceTest()));
    }

    static class StaticTest {
        private static int i1 = 1;
        private static int i2 = 1;
        private static int i3 = 1;
        private static int i4 = 1;
        private static int i5 = 1;
        private static int i6 = 1;
    }

    static class StaticReferenceTest {
        private static Object o1 = new Object();
        private static Object o2 = new Object();
        private static Object o3 = new Object();
        private static Object o4 = new Object();
        private static Object o5 = new Object();

    }
}

代碼中還有一點其他測試： https://github.com/Deeeeeeeee/jcoding.git

對象頭在 64 位的時候，為什么是 8 個字節；32 位的時候，為什么是 4 個字節

一個引用在 64 位的時候，為什么是 8 個字節；32 位的時候，為什么是 4 個字節

這個跟 C++ 指針有關了，跟寄存器有關了

指針壓縮又是怎么個回事

這一切都可以在 jvm 的實現中找到答案，也就是看 C++ 代碼。只是我還沒到這個階段=。=

【Java對象解析】不得不了解的對象頭

JDK從6 update 23開始在64位系統上會默認開啟壓縮指針

【Java JVM】 Hotspot GC研究- 64位引用指針壓縮技術