一文看懂Java 对象的内存

说明

本文绝大多数内容，都是直接摘自 高端面试必备：一个 Java 对象占用多大内存，因为这篇文章写得太好了，我觉得没有必要重新写一遍了 0_o

Java 对象模型

HotSpot JVM 使用名为 oops (Ordinary Object Pointers) 的数据结构来表示对象。这些 oops 等同于本地 C 指针。 instanceOops 是一种特殊的 oop，表示 Java 中的对象实例。

在 Hotspot VM 中，对象在内存中的存储布局分为 3 块区域：

• 对象头（Header）
• 实例数据（Instance Data）
• 对齐填充（Padding）

对象头又包括三部分：MarkWord、元数据指针、数组长度。

• MarkWord：用于存储对象运行时的数据，好比 HashCode、锁状态标志、GC 分代年龄等。这部分在 64 位操作系统下占 8 字节，32 位操作系统下占 4 字节。
• 指针：对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪一个类的实例。
  这部分就涉及到指针压缩的概念，在开启指针压缩的状况下占 4 字节，未开启状况下占 8 字节。
• 数组长度：这部分只有是数组对象才有，若是是非数组对象就没这部分。这部分占 4 字节。

实例数据就不用说了，用于存储对象中的各类类型的字段信息（包括从父类继承来的）。

关于对齐填充，Java 对象的大小默认是按照 8 字节对齐，也就是说 Java 对象的大小必须是 8 字节的倍数。若是算到最后不够 8 字节的话，那么就会进行对齐填充。

那么为何非要进行 8 字节对齐呢？这样岂不是浪费了空间资源？

其实不然，由于 CPU 进行内存访问时，一次寻址的指针大小是 8 字节，正好也是 L1 缓存行的大小。如果不进行内存对齐，则可能出现跨缓存行的情况，这叫做 缓存行污染。

由于当 obj1 对象的字段被修改后，那么 CPU 在访问 obj2 对象时，必须将其重新加载到缓存行，因此影响了程序执行效率。

也就说，8 字节对齐，是为了效率的提高，以空间换时间的一种方案。固然你还能够 16 字节对齐，可是 8 字节是最优选择。

正如我们之前看到的，JVM 为对象进行填充，使其大小变为 8 个字节的倍数。使用这些填充后，oops 中的最后三位始终为零。这是因为在二进制中 8 的倍数的数字总是以 000 结尾。

由于 JVM 已经知道最后三位始终为零，因此在堆中存储那些零是没有意义的。相反假设它们存在并存储 3 个其他更重要的位，以此来模拟 35 位的内存地址。现在我们有一个带有 3 个右移零的 32 位地址，所以我们将 35 位指针压缩成 32 位指针。这意味着我们可以在不使用 64 位引用的情况下使用最多 32 GB。

基本类型占用存储空间和指针压缩

基础对象占用存储空间

Java 基础对象在内存中占用的空间如下：

类型	占用空间 (byte)
boolean	1
byte	1
short	2
char	2
int	4
float	4
long	8
double	8

另外，引用类型在 32 位系统上每个引用对象占用 4 byte，在 64 位系统上每个引用对象占用 8 byte。

Java 中基础数据类型是在栈上分配还是在堆上分配？

我们继续深究一下，基本数据类占用内存大小是固定的，那具体是在哪分配的呢，是在堆还是栈还是方法区？大家不妨想想看！ 要解答这个问题，首先要看这个数据类型在哪里定义的，有以下三种情况。

• 如果在方法体内定义的，这时候就是在栈上分配的
• 如果是类的成员变量，这时候就是在堆上分配的
• 如果是类的静态成员变量，在方法区上分配的

指针压缩

引用类型在 64 位系统上占用 8 个字节，虽然一个并不大，但是耐不住多。

所以为了解决这个问题，JDK 1.6 开始 64 bit JVM 正式支持了 -XX:+UseCompressedOops （需要 jdk1.6.0_14) ，这个参数可以压缩指针。

启用 CompressOops 后，会压缩的对象包括：

• 对象的全局静态变量（即类属性）；
• 对象头信息：64 位系统下，原生对象头大小为 16 字节，压缩后为 12 字节；
• 对象的引用类型：64 位系统下，引用类型本身大小为 8 字节，压缩后为 4 字节；
• 对象数组类型：64 位平台下，数组类型本身大小为 24 字节，压缩后 16 字节。

当然压缩也不是万能的，针对一些特殊类型的指针 JVM 是不会优化的。 比如：

• 指向非 Heap 的对象指针
• 局部变量、传参、返回值、NULL 指针。

CompressedOops 工作原理

32 位内最多可以表示 4GB，64 位地址为 堆的基地址 + 偏移量，当堆内存 < 32GB 时候，在压缩过程中，把 偏移量 / 8 后保存到 32 位地址。在解压再把 32 位地址放大 8 倍，所以启用 CompressedOops 的条件是堆内存要在 4GB * 8=32GB 以内。

Java 对象到底占用多大内存

前面我们分析了 Java 对象到底都包含哪些东西，所以现在我们可以开始剖析一个 Java 对象到底占用多大内存。

由于现在基本都是 64 位的虚拟机，所以后面的讨论都是基于 64 位虚拟机。 首先记住公式，对象由 对象头 + 实例数据 + padding 填充字节组成，虚拟机规范要求对象所占内存必须是 8 的倍数，padding 就是干这个的。

上面说过对象头由 Markword + 类指针 kclass（该指针指向该类型在方法区的元类型） 组成。

JDK 分析 JVM 对象布局工具

JDK 提供了一个工具，JOL 全称为 Java Object Layout，是分析 JVM 中对象布局的工具，该工具大量使用了 Unsafe、JVMTI 来解码布局情况。下面我们就使用这个工具来获取一个 Java 对象的大小。

<dependency>
    <groupId>org.openjdk.jol</groupId>
    <artifactId>jol-core</artifactId>
    <version>0.16</version>
</dependency>

测试空对象

创建一个空的对象 A，里面什么都没有。

static class A {
}

测试代码：

@Test
public void testEmptyClass() {
    ClassLayout classLayout = ClassLayout.parseInstance(new A());
    System.out.println(classLayout.toPrintable());
}

启用 oop

首先看一下启用了 oop 的内存分布，我们在单元测试的启动参数中，加入-XX:+UseCompressedOops：

执行单元测试，输出结果如下：

test.jdk.ClassSizeTest$A object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4        (object header: class)    0x08014b4f
 12   4        (object alignment gap)    
Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total

可以看出 class A 的对象实例，object header: mark 是 8 个字节，object header: class 是 4 个字节，由于两个加起来是 12 个字节，并不是 8 的整数倍，所以填充了 4 个字节，最终对象实例占用了 16 个字节。

禁用 oop

接着看一下禁用 oop 的内存分布，单元测试的启动参数中，加入-XX:-UseCompressedOops（注意中间是减号，不是加号）：

执行单元测试，输出结果如下：

test.jdk.ClassSizeTest$A object internals:
OFF  SZ   TYPE DESCRIPTION               VALUE
  0   8        (object header: mark)     0x000000000000000d (biasable; age: 1)
  8   8        (object header: class)    0x0000000232b9b0e0
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total

可以看出 class A 的对象实例，object header: mark 是 8 个字节，object header: class 也是 8 个字节，由于两个加起来是 16 个字节，是 8 的整数倍，所以没有填充，最终对象实例占用了 16 个字节，没有空间损失。

测试复杂对象

这次对象复杂一点，里面有 4 个变量：占 4 字节的 int 型，占 1 个字节的布尔型，占 8 个字节的 double 型，占 1 个字节的布尔型。

static class B {
    int a;
    boolean b;
    double c;
    boolean d;
}

测试的单元方法如下：

@Test
public void testClass() {
    ClassLayout classLayout = ClassLayout.parseInstance(new B());
    System.out.println(classLayout.toPrintable());
}

启用 oop

test.jdk.ClassSizeTest$B object internals:
OFF  SZ      TYPE DESCRIPTION               VALUE
  0   8           (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4           (object header: class)    0x08016f76
 12   4       int B.a                       0
 16   8    double B.c                       0.0
 24   1   boolean B.b                       false
 25   1   boolean B.d                       false
 26   6           (object alignment gap)    
Instance size: 32 bytes
Space losses: 0 bytes internal + 6 bytes external = 6 bytes total

首先可以看到，class B 对象实例内部并没有按照代码里的声明顺序，B 中有 2 个布尔值，每个都占 1 个字节，实例变量中这 2 个变量是分配在了对象的最后，这样能够节省空间。最终这个对象只浪费了 6 个字节作地址对齐。

禁用 oop

test.jdk.ClassSizeTest$B object internals:
OFF  SZ      TYPE DESCRIPTION               VALUE
  0   8           (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   8           (object header: class)    0x000000023b87aac8
 16   8    double B.c                       0.0
 24   4       int B.a                       0
 28   1   boolean B.b                       false
 29   1   boolean B.d                       false
 30   2           (object alignment gap)    
Instance size: 32 bytes
Space losses: 0 bytes internal + 2 bytes external = 2 bytes total

写不动了，不分析了……

包含对象引用的对象

在上面 class B 的基础上，再加一个引用类型~

static class C {
    int a;
    boolean b;
    double c;
    boolean d;
    Integer e;
}

单元测试代码：

@Test
public void testClass2() {
    ClassLayout classLayout = ClassLayout.parseInstance(new C());
    System.out.println(classLayout.toPrintable());
}

启用 oop

test.jdk.ClassSizeTest$C object internals:
OFF  SZ                TYPE DESCRIPTION               VALUE
  0   8                     (object header: mark)     0x0000000000000005 (biasable; age: 0)
  8   4                     (object header: class)    0x08014b91
 12   4                 int C.a                       0
 16   8              double C.c                       0.0
 24   1             boolean C.b                       false
 25   1             boolean C.d                       false
 26   2                     (alignment/padding gap)   
 28   4   java.lang.Integer C.e                       null
Instance size: 32 bytes
Space losses: 2 bytes internal + 0 bytes external = 2 bytes total

和上面示例的区别，主要在下面这 2 行：

26   2                     (alignment/padding gap)   
28   4   java.lang.Integer C.e                       null

C 的实例对象总共占用了 32 个字节，其中内部因为对齐损失了 2 个字节，外部没有损失。Integer 对象的引用是占 4 个字节的。

禁用 oop

test.jdk.ClassSizeTest$C object internals:
OFF  SZ                TYPE DESCRIPTION               VALUE
  0   8                     (object header: mark)     0x000000000000000d (biasable; age: 1)
  8   8                     (object header: class)    0x000000023537aae8
 16   8              double C.c                       0.0
 24   4                 int C.a                       0
 28   1             boolean C.b                       false
 29   1             boolean C.d                       false
 30   2                     (alignment/padding gap)   
 32   8   java.lang.Integer C.e                       null
Instance size: 40 bytes
Space losses: 2 bytes internal + 0 bytes external = 2 bytes total

C 的实例对象总共占用了 40 个字节，其中内部因为对齐损失了 2 个字节，外部没有损失。Integer 对象的引用是占 8 个字节的。

总结

• 引用类型大小：在 64 位系统上占用 8 字节，开启指针压缩 oop 后占用 4 字节；在 32 位系统上占用 4 字节。
• 对象占用大小：对象头+实例数据+padding 填充字节，对象所占字节必须是 8 的整数倍。
• 对象头大小：在 64 位系统上占用 16 字节，开启指针压缩 oop 后占用 12 个字节。
• 指针压缩的对象（64 位系统）：
  • 对象的全局静态变量
  • 对象头信息（由 16 字节→12 字节）
  • 对象的引用类型（由 8 字节→4 字节）
  • 对象数组类型（由 24 字节→16 字节）