JVM 对象内存分配和对象内存布局

对象创建流程

在代码中，通过new创建新的对象时会经过如下几个流程：

1. 类是否加载
   当遇到new的字节码指令时，会检查创建实例所属的类是否加载，主要是通过当前类的常量池中的符号引用来确定需要加载的类，如果类未加载则加载指定的类。

2. 分配内存
   从堆内存中为要创建的对象分配内存。
   内存分配有两种方法：
   指针碰撞（Bump the Pointer）:如果Java的堆内存时规整的，已经分配
   的空间在一遍，未分配的空间在另外一遍，中间则使用一个指示器用于划分
   已分配空间和未分配空间的边界，当需要分配空间时，将指针移动指定空
   间，从而实现内存的分配。
   空闲列表（Free List） 如果Java的堆内存是不规则的，已分配的和未分
   配的空间交错存在，那么使用指针碰撞明显就不合理了，可以通过维护一个
   列表，用于记录已分配的空间和未分配的空间，当需要空间分配时，从列表
   中查找空闲空间并将状态修改为已分配。

   但是随之而来的问题是，对象的分配时并发进行的，多个线程可能会在同时创建新的对象并分配空间，所以就会存在分配并发问题，解决这种问题有两种方案：
   使用CAS加失败重试：分配使用CAS,当失败后进行重试，直至空间分配成功。
   本地线程分配缓冲区（Thread Loacal Allocation Buffer, TLAB）： 把内存为每一线程划分成一块“私有”的空间，那么线程在创建对象时使用分配的空间，而另一线程创建对象使用另一个分配的空间，在单线程中是不存在并发问题的。只有在为每一个线程分配TLAB时再次进行加锁。这大大增加了效率。

3. 初始化
   内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头）， 如果使用TLAB，这一工作过程也 可以提前至TLAB分配时进行。这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，程序能访问 到这些字段的数据类型所对应的零值。

4. 设置对象头
   初始化零值之后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对 象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头Object Header之中。 在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、 实例数据（Instance Data） 和对齐填充（Padding）。 HotSpot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的运行时数据， 如哈 希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时 间戳等。对象头的另外一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

5. 执行<init>方法
   执行<init>方法，即对象按照程序员的意愿进行初始化。对应到语言层面上讲，就是为属性赋值（注意，这与上面的赋 零值不同，这是由程序员赋的值），和执行构造方法。

对象内存布局

在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、 实例数据（Instance Data） 和对齐填充（Padding）。

对象头

HotSpot虚拟机的对象头包括两部分信息，第一部分用于存储对象自身的运行时数据， 如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时 间戳等,，称之为Mark Word。对象头的另外一部分是类型指针，即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。 首先来看一下32虚拟机下对象的对象头的Markword，32bit为用于标识的信息：

对象头中还包括类型指针（Klass Pointer），其在32位占4字节，在64为占8字节（开启指针压缩的时占4字节）。该部分存储的是对象所属类的类元信息在元空间的地址。
对于数组，由于无法确定其长度，所以数组对象的对象头会用4字节存储数组的长度。

实例数据

实例数据也就是在类中定义的包括基础类型的和引用类型的属性，对于基础类型byte、short、char、int、float、double、long和boolean，占用空间与基础类型的长度一致，对于引用类型，在32位中为4字节，在64位中为8字节（当然开启指针压缩的话为4字节，不开始时为8字节）。

对齐填充

为了方便内存的管理，防止碎散的空间，已经定位的效率，所以要求对象占用空间为8字节或者8字节的整数倍，所以在对象头和实例数据的占用的空间不足时，将使用对齐填充将其补够8字节或者其整数倍。

对象内存布局如下：

接下来我们可以通过jol-core包来查看参数对象的内存布局，首先引入依赖包，如下：

<!-- https://mvnrepository.com/artifact/org.openjdk.jol/jol-core --> <dependency> <groupId>org.openjdk.jol</groupId> <artifactId>jol-core</artifactId> <version>0.9</version> </dependency> 

示例代码如下：

/**
 * @Description: 对象内存布局测试
 *                  -XX:-UseCompressedClassPointers -XX:-UseCompressedOops
 * @Author: binga
 * @Date: 2020/8/27 14:18
 * @Blog: https://blog.csdn.net/pang5356
 */ public class ObjectLayoutTest { public static void main(String[] args) { // Object对象 ClassLayout objLayout = ClassLayout.parseInstance(new Object()); System.out.println(objLayout.toPrintable()); System.out.println("--------------------------------------------"); // 数组对象 ClassLayout arrayLayout = ClassLayout.parseInstance(new int[]{}); System.out.println(arrayLayout.toPrintable()); System.out.println("--------------------------------------------"); // 自定义User对象 ClassLayout userLayout = ClassLayout.parseInstance(new User()); System.out.println(userLayout.toPrintable()); } } class User { private String name; // 不开启指针压缩，引用类型占用8字节，开启后占4字节 private int age; // 4字节 private byte sex; // 1字节，并填充3字节 private Object obj; // 不开启指针压缩，引用类型占用8字节，开启后占4字节 } 

在测试前，指定不开启指针压缩，通过如下参数指定：

-XX:-UseCompressedClassPointers -XX:-UseCompressedOops 

运行结果如下：

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4 (object header) 19 00 00 00 (00011001 00000000 00000000 00000000) (25) 4     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8     4 (object header) 10 1c 19 17 (00010000 00011100 00011001 00010111) (387521552) 12     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total


-------------------------------------------- [I 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) 68 0b 19 17 (01101000 00001011 00011001 00010111) (387517288) 12     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 16     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 20     4 (alignment/padding gap) 24     0    int [I.<elements> N/A
Instance size: 24 bytes
Space losses: 4 bytes internal + 0 bytes external = 4 bytes total


--------------------------------------------
com.binga.jvm.objlayout.User object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8     4 (object header) b8 41 6b 17 (10111000 01000001 01101011 00010111) (392905144) 12     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 16     4                int User.age                                  0
     20     1               byte User.sex                                  0
     21     3 (alignment/padding gap) 24     8   java.lang.String User.name                                 null
     32     8   java.lang.Object User.obj                                  null
Instance size: 40 bytes
Space losses: 3 bytes internal + 0 bytes external = 3 bytes total 

针对Object,其对象头中Markword占去8字节（64为），而类型指针（Klass Pointer）没有开启指针压缩也占8字节，所以整个对象占16字节。对于int[]，对象头Mark word占8字节，类型指针（Klass Pointer）占8字节，数组长度占去4字节，再加上对其填充一共24字节。对于User的实例，对象头占18字节，name和obj由于没有开启指针压缩，都是占8字节，对于int类型的age占4字节，而对于byte类型的sex占1字节，但是在内部填充有3字节，总共占40字节。
那么开启指针压缩的话，只需要将两个参数删除即可（默认开启），运行结果如下：

java.lang.Object object internals:
 OFFSET  SIZE   TYPE DESCRIPTION                               VALUE
      0     4 (object header) 21 00 00 00 (00100001 00000000 00000000 00000000) (33) 4     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8     4 (object header) e5 01 00 20 (11100101 00000001 00000000 00100000) (536871397) 12     4 (loss due to the next object alignment) Instance size: 16 bytes
Space losses: 0 bytes internal + 4 bytes external = 4 bytes total


-------------------------------------------- [I 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) 6d 01 00 20 (01101101 00000001 00000000 00100000) (536871277) 12     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 16     0    int [I.<elements> N/A
Instance size: 16 bytes
Space losses: 0 bytes internal + 0 bytes external = 0 bytes total


--------------------------------------------
com.binga.jvm.objlayout.User object internals:
 OFFSET  SIZE               TYPE DESCRIPTION                               VALUE
      0     4 (object header) 05 00 00 00 (00000101 00000000 00000000 00000000) (5) 4     4 (object header) 00 00 00 00 (00000000 00000000 00000000 00000000) (0) 8     4 (object header) 61 cc 00 20 (01100001 11001100 00000000 00100000) (536923233) 12     4                int User.age                                  0
     16     1               byte User.sex                                  0
     17     3 (alignment/padding gap) 20     4   java.lang.String User.name                                 null
     24     4   java.lang.Object User.obj                                  null
     28     4 (loss due to the next object alignment) Instance size: 32 bytes
Space losses: 3 bytes internal + 4 bytes external = 7 bytes total 

指针压缩

什么是java对象的指针压缩？

1. jdk1.6 update14开始，在64bit操作系统中，JVM支持指针压缩 。

2. jvm配置参数:UseCompressedOops。compressed­­压缩、oop(ordinary object
   pointer)­­对象指针。

3. 启用指针压缩:­XX:+UseCompressedOops(默认开启)，禁止指针压缩参数如下：

   -­XX:-­UseCompressedOops 

为什么要进行指针压缩？

1. 在64位平台的HotSpot中使用32位指针，内存使用会多出1.5倍左右，使用较大指针在主内存和缓存之间移动数据，占用较大宽带，同时GC也会承受较大压力。
2. 为了减少64位平台下内存的消耗，启用指针压缩功能 。
3. 在jvm中，32位地址最大支持4G内存(2的32次方)，可以通过对对象指针的压缩编码、解码方式进行优化，使得jvm只用32位地址就可以支持更大的内存配置(小于等于32G)。
4. 堆内存小于4G时，不需要启用指针压缩，jvm会直接去除高32位地址，即使用低虚拟地址空间 。
5. 堆内存大于32G时，压缩指针会失效，会强制使用64位(即8字节)来对java对象寻址，这就会出现1的问题，所以堆内 存不要大于32G为好。

本文地址：https://blog.csdn.net/pang5356/article/details/108261752