点赞关注，不再迷路，你的支持对我意义重大！

🔥 Hi，我是丑丑。本文「Java 路线」| 导读 —— 他山之石，可以攻玉已收录，这里有 Android 进阶成长路线笔记 & 博客，欢迎跟着彭丑丑一起成长。（联系方式在 GitHub）

前言

Java 对象是接触得很多的，对 Java 对象 内存布局 & 访问 的正确理解，也是 Java 编程的基础；
在这篇文章里，我将通过 Object obj = new Object()占用多少字节？ 这个问题为线索，与你探讨 Java 堆上对象的内存布局 & 访问。如果能帮上忙，请务必点赞加关注，这真的对我非常重要。

延伸文章

对于锁 & 锁升级的流程不太了解，请阅读：《Java | 锁的四种状态与锁升级过程》（Editting...）
对于Object#hashcode()不太了解，请阅读：《Java | 多次调用 hashcode()，返回值一样吗？》（Editting...）

1. 实验结果

JOL（Java Object Layout）是 OpenJDK 提供的用于分析对象内存布局的工具，地址：JOL。主要的局限性是只支持 HotSpot/OpenJDK 虚拟机，如果在其他虚拟机上使用会报错：

java.lang.IllegalStateException: Only HotSpot/OpenJDK VMs are supported

现在，我们使用JOL分析 new Object() 在 HotSpot 虚拟机上的内存布局：

步骤一：添加依赖
implementation 'org.openjdk.jol:jol-core:0.11'

步骤二：创建对象
Object obj = new Object();

步骤三：打印对象内存布局

1. 输出虚拟机与对象内存布局相关的信息
System.out.println(VM.current().details());
2. 输出对象内存布局信息
System.out.println(ClassLayout.parseInstance(obj).toPrintable());

输出结果如下：

# Running 64-bit HotSpot VM.
# Using compressed oop with 3-bit shift.
# Using compressed klass with 3-bit shift.
# Objects are 8 bytes aligned.
# Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]
# Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION        VALUE
      0     4        (object header)    01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)    00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)    e5 01 00 f8 (11100101 00000001 00000000 11111000) (-134217243)
     12     4        (loss due to the next object alignment)
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

其中关于虚拟机的信息：

Running 64-bit HotSpot VM. 表示运行在64位的 HotSpot 虚拟机
Using compressed oop with 3-bit shift. 指针压缩
Using compressed klass with 3-bit shift. 指针压缩
Objects are 8 bytes aligned. 表示对象按 8 字节对齐
Field sizes by type: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes] ，依次表示引用、boolean、byte、char、short、int、float、long、double类型占用的长度，见源码：

HotspotUnsafe.java

public String details() {
    // ...
    out.printf("# %-19s: %d, %d, %d, %d, %d, %d, %d, %d, %d [bytes]%n",
                "Field sizes by type",
                oopSize,
                sizes.booleanSize,
                sizes.byteSize,
                sizes.charSize,
                sizes.shortSize,
                sizes.intSize,
                sizes.floatSize,
                sizes.longSize,
                sizes.doubleSize
        );
}

Array element sizes: 4, 1, 1, 2, 2, 4, 4, 8, 8 [bytes]，依次表示数组元素长度

其中关于Object对象的信息里，虽然存在很多不理解的数据，但是至少可以清楚地看到Instance size: 16 bytes 。这个是不是就是题目的答案呢？

2. 对象内存布局的基本结构

3. 对象头（Header）

对象头包含 Mark Work & 类型指针 & 数组长度。

3.1 Mark Work

由于对象头里的信息是与对象实例数据无关的额外存储成本，Mark Word 被设计为一个有状态的数据结构，可以根据对象的状态复用。

3.2 类型指针（Class Pointer）

定义： 指向方法区中的类型元数据，可选，取决于对象的访问定位方式；
长度： 在 32 位机器上占用 4 个字节，在 64 位机器上占 8 个字节。虚拟机（默认）通过 指针压缩 将长度压缩到 4 个字节，通过以下虚拟机参数控制。

-XX:+UseCompressedClassPointers -XX:+UseCompressedOops

注意： 并不是所有虚拟机实现都将类型指针存在对象数据上。具体取决于虚拟机使用的 对象的访问定位 方式，如果是使用 直接指针 的方式，对象的内存布局就必须放置访问类型数据的指针。

3.3 数组长度

定义： 指数组对象的长度，注意这里的长度指的是元素个数，非占用内存空间（可选，只有数组对象才有）；
长度： 4 个字节；
描述： 普通 Java 对象的大小可以通过元数据信息确定，但是对于数组对象来说，无法通过元数据的信息确定数组的长度。因此，如果对象是一个Java数组，那么对象头中会有一块记录数组长度的区域。例如：

源码：
char [] str = new char[2];
System.out.println(ClassLayout.parseInstance(str).toPrintable());

------------------------------------------------------
JOL：
[C object internals:
 OFFSET  SIZE   TYPE DESCRIPTION        VALUE
      0     4        (object header)    01 00 00 00 (00000001 00000000 00000000 00000000) (1)
      4     4        (object header)    00 00 00 00 (00000000 00000000 00000000 00000000) (0)
      8     4        (object header)    41 00 00 f8 (01000001 00000000 00000000 11111000) (-134217663)
     12     4        (object header)    【数组长度：2】02 00 00 00 (00000010 00000000 00000000 00000000) (2)
     16     4   char [C.<elements>     N/A
     20     4        (loss due to the next object alignment)
Instance size: 24 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

可以看到，对象头中有一块 4 字节的区域，值为2，表示该数组长度为 2。

4. 实例数据（Instance Data）

实例数据是对象的有效信息，可以理解为报文段中的 payload。

对象的实例数据包括：

本类声明的实例字段
从父类继承的实例字段

但不包括类级字段（存储在方法区）。

字段的存储顺序与字段声明顺序和分配策略参数有关：

相同宽度的字段分配在一起

longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers，OOPs）

父类字段在子类字段之前
使用-XX： FieldsAllocationStyle、+XX：CompactFields可以影响分配策略

5. 对齐填充（Padding）

HotSpot 虚拟机对象的大小必须按 8 字节对齐（即第一节中Objects are 8 bytes aligned.的含义），如果对象占用空间不是 8 字节的倍数，则需要增加对齐填充数据。

直观来看，“无效” 的填充数据使得对象占用空间加大，增大了虚拟机的内存消耗。那么为什么要这么做呢？**我认为有以下原因：

？

6. 对象的访问定位方式

我们都知道 Java 的类型可以分为基础数据类型与引用类型（Reference）。对于引用类型变量，在虚拟机栈上存储的只是 Reference，而对象真正的示例数据是存储在堆上。

通过 Reference 访问对象示例数据的方式分为分为 句柄访问 & 直接指针访问：

6.1 句柄访问

在 Java 堆中单独划分一块区域作为句柄池，Reference 中存储是对象的句柄。句柄中存储的是对象实例数据与类型数据的地址。

句柄访问的优点是句柄中对象实例数据和类型数据的地址是稳定的，当对象在垃圾收集是被移动时，只需要修改实例数据的指针，而 Reference 本身不需要修改。

引用自《深入理解Java虚拟机（第3版本）》—— 周志明著

6.2 直接指针访问

Reference 中存储的是指向对象的地址，对象内存中有一块是实例数据，另外有一个指针指向类型数据，这个指针就是 第 2.1.2 节 中的类型指针（Class Pointer）

直接指针访问的优点是速度更快，因为节省了一次指针的访问。由于在 Java 虚拟机中对象访问的频率非常高，所以直接指针访问的优势更明显。