HotSpot对象、对象的创建、对象的内存布局、对象的访问定位

概述

深入探讨一下HotSpot虚拟机在Java堆中对象分配、布局 和访问的全过程

对象的创建

new 一个对象是怎么一个过程呢？

当JVM遇到一条字节码new指令时，首先将去检查这个指令的参数是否在常量池中定位到一个类的符号引用，

编译时会产生Class文件，class常量池作为class文件的一部分，包括了类版本，字段，方法，接口，常量池表（字面量、符号引用）

在类加载时，class常量池会储存在运行时常量池中

并且检查这个符号引用代表的类是否已被加载、解析、初始化过。
如果没有，那么必须先执行相应的类加载过程。
在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务实际上等同于把一块确定大小的内存块重Java堆中划分出来。

假设Java堆中内存是绝对规整的，所有被使用过的内存都被放到一边，空闲的内存空间方向挪动一段与对象大小相等的距离，这种分配方式成为“指针碰撞”。

但如果Java堆中的内存并不是规整的，已被使用的内存和空闲的内存相互交错在一起，那就没法进行指针碰撞，虚拟机就必须维护一个列表，记录那些内存可用，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录，这种分配方式称类“空闲列表”

选择哪种分配方式由Java堆是否规整决定，而Java堆是否规整又由所采用的垃圾收集器是否带有空间压缩整理的能力决定。因此，当使用Serial，Parnew等带压缩整理过程的收集器时，系统采用的分配算法是指针碰撞，既简单又高效；而当使用CMS这种基于清楚（Sweep）算法收集器时，理论上就只能采用较为复杂的空间列表来分配内存。

除如何划分可用空间之外，还需要考虑创建对象在虚拟机中是非常频繁的行为，即时仅仅修改一个指针所指向的位置，在并发情况下也并非不是线程安全的，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。解决这个问题有两种可选方案：

• 一种是对分配内存空间的动作进行同步处理——实际上虚拟机是采用CAS配上失败重试的方式保证更新操作的原子性；
• 另外一种是把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存，称为本地线程分配缓冲（Thread Local Allocation Buffer，TLAB），那个线程要分配内存，就先在那个线程的本地缓冲区分配，本地缓冲区用完了，分配新的缓存区时才需要同步锁定。虚拟机是否使用TLAB，可以通过-XX:+/-UseTLAB参数来设定。

内存分配完成之后，虚拟机必须将分配到内存空间（但不包括对象头）都初始化为零值，如果使用了TLAB的话，这项工作提前至TLAB分配时执行。这步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用。

接下来，Java虚拟机还要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希码（实际上对象的哈希码会延后到真正调用Object::hashCode()方法时才 计算）、对象的GC分代年龄等信息。这些信息存放在对象的对象头之中。根据虚拟机当前运行状态的不同，如是否启动偏向锁等，对象头会有不同的设置方式。

在上面工作都完成之后，从虚拟机视角来看，一个新的对象已产生，但是从Java程序的视角来看，对象创建才刚刚开始——构造函数，即Class文件中的()方法还没有执行，所有的字段都为默认的零值，对象需要的其他资源和状态也还没有按照预定的意图构造好。new指令之后会接着执行()方法，按照程序员的意愿对对象进行初始化，这样一个真正可用的对象才算完全被构造出来。

总结一下 new 一个对象的流程

Java中new一个对象的步骤：
1. 当虚拟机遇到一条new指令时候，首先去检查这个指令的参数是否能 在常量池中能否定位到一个类的符号引用 （即类的带路径全名），并且检查这个符号引用代表的类是否已被加载、解析和初始化过，即验证是否是第一次使用该类。如果没有（不是第一次使用），那必须先执行相应的类加载过程（class.forname()）。
2. 在类加载检查通过后，接下来虚拟机将 为新生的对象分配内存 。对象所需的内存的大小在类加载完成后便可以完全确定，为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来，目前常用的有两种方式，根据使用的垃圾收集器是否具有空间压缩整理能力来决定使用哪种分配机制：
　　2.1. 指针碰撞（Bump the Pointer）：假设Java堆的内存是绝对规整的，所有用过的内存都放一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅把那个指针向空闲空间那边挪动一段与对象大小相等的距离。
　　2.2. 空闲列表（Free List）：如果Java堆中的内存并不是规整的，已使用的内存和空间的内存是相互交错的，虚拟机必须维护一个空闲列表，记录上哪些内存块是可用的，在分配时候从列表中找到一块足够大的空间划分给对象使用。
3. 内存分配完后，虚拟机需要将分配到的内存空间中的数据类型都 初始化为零值（不包括对象头）；
4. 虚拟机要 对对象头进行必要的设置 ，例如这个对象是哪个类的实例（即所属类）、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息，这些信息都存放在对象的对象头中。
至此，从虚拟机视角来看，一个新的对象已经产生了。但是在Java程序视角来看，执行new操作后会接着执行如下步骤：
5.  调用对象的init()方法 ,根据传入的属性值给对象属性赋值。
6. 在线程 栈中新建对象引用 ，并指向堆中刚刚新建的对象实例。

对象的内存布局

在HotSpot虚拟机中，对象在堆内存中的存储布局可以划分为三个部分：对象头(Header)、实例数据(Instance Data)和对齐填充(Padding)。

对象头

HotSpot虚拟机对象的对象头部分包括两类信息。第一类是用于储存对象自身的运行时数据，如哈希码(HashCode)、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等，这部分数据的长度在32位和64位虚拟机（未开启压缩指针）中分别为32bit和64bit，官方称它为“Mark Word”。 对象需要储存的运行时数据很多，其实超过了32、64位Bitmap结构所能记录的最大限度，但对象头里的信息是与对象自身定义的数据无关的额外存储成本，考虑到虚拟机的空间效率，Mark Word被设计成一个有着动态定义的数据结构，一边在极小的空间内存储尽量多的数据，根据对象的状态复用自己的存储空间。

例如32位的HotSpot虚拟机中，如对象未被同步锁锁定的状态下，Mark Word的32bit储存空间中25个比特用于储存对象哈希码，4个比特用于储存对象分代年龄，2个bit用存储锁标志位，1个bit固定为0，在其它状态（轻量级锁、重量级锁、GC标记、可偏向）下对象存储内容如表2-1所示

储存内容	标志位	状态
对象哈希码、对象分代年龄	01	未锁定
指向锁记录的指针	00	轻量级 锁
指向重量级锁指针	10	膨胀（重量级锁定 ）
空，不需要记录信息	11	GC标记
偏向线程ID，偏向时间戳，对象分代年龄	01	可偏向

|-------------------------------------------------------|--------------------|
|                  Mark Word (32 bits)                  |       State        |
|-------------------------------------------------------|--------------------|
| identity_hashcode:25 | age:4 | biased_lock:1 | lock:2 |       Normal       |
|-------------------------------------------------------|--------------------|
|  thread:23 | epoch:2 | age:4 | biased_lock:1 | lock:2 |       Biased       |
|-------------------------------------------------------|--------------------|
|               ptr_to_lock_record:30          | lock:2 | Lightweight Locked |
|-------------------------------------------------------|--------------------|
|               ptr_to_heavyweight_monitor:30  | lock:2 | Heavyweight Locked |
|-------------------------------------------------------|--------------------|
|                                              | lock:2 |    Marked for GC   |
|-------------------------------------------------------|--------------------|

如果是64位指针压缩情况下Mark Word布局会是怎样？
参考文章：https://blog.csdn.net/baidu_28523317/article/details/104453927

biased_lock：对象是否启用偏向锁标记，只占1个二进制位。为1时表示对象启用偏向锁，为0时表示对象没有偏向锁。
age：4位的Java对象年龄。在GC中，如果对象在Survivor区复制一次，年龄增加1。当对象达到设定的阈值时，将会晋升到老年代。默认情况下，并行GC的年龄阈值为15，并发GC的年龄阈值为6。由于age只有4位，所以最大值为15，这就是-XX:MaxTenuringThreshold选项最大值为15的原因。
identity_hashcode：25位的对象标识Hash码，采用延迟加载技术。调用方法System.identityHashCode()计算，并会将结果写到该对象头中。当对象被锁定时，该值会移动到管程Monitor中。
thread：持有偏向锁的线程ID。
epoch：偏向时间戳。
ptr_to_lock_record：指向栈中锁记录的指针。
ptr_to_heavyweight_monitor：指向管程Monitor的指针。

对象头的另外一部分是类型指针，即对象指向它的类型元数据的指针，Java虚拟机通过这个指针来确定对象是那个类的实例。 并不是所有的虚拟机实现都必须在对象数据上保留类型指针。
此外，如果对象是数组，那么对象头中还必须有一块用于记录数组长度的数据，因为无法通过元数据中的信息推断数组的大小。

实例数据

实例数据是对象真正存储有效的信息，即我们在程序代码里面所定义的各种类型的字 段内容，无论是从父类继承下来的，还是在子类中定义的字段都必须记录起来。这部分存储顺序会受到虚拟机分配策略参数（-XX:FieldsAllocationStyle参数）和字段在Java源码中定义顺序的影响。HotSpot虚拟机默认的分配顺序为longs/doubles、ints、shorts/chars、bytes/booleans、oops（Ordinary Object Pointers，OOPs），从以上默认的分配策略中可以看到，相同宽度的字段总是被分配到一起存 放，在满足这个前提条件的情况下,在父类中定义的变量会出现在子类之前。如果HotSpot虚拟机的+XX：：CompactFields参数值为true（默认为True）,那子类之中较窄的变量也允许插入父类变量的空 隙之中，以节省出一点点空间。

对齐填充

对象的第三部分是对齐填充，这并不是必然存在的，也没有特别含义，它仅仅起着占位符的作用。由于HotSpot虚拟机的自动内存管理系统要求对象起止必须是8字节的整数倍，换句话说就是任何对象的大小都必须是8的正数倍。如果对象实例数据部分没有对齐的话，就需要通过对齐填充来补全。

测试

我们可以利用JOL工具来进行试验测试

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

Obj.class

public class Obj {
    private Integer age;
    private char c;
}

Main

public class Demo {
    private static Obj obj = new Obj();
    public static void main(String[] args) {
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

结果

MarkWord值如何读，跟你从图中看到的正好相反。这里涉及到一个知识点“大端存储与小端存储”。

• Little-Endian：低位字节存放在内存的低地址端，高位字节存放在内存的高地址端。
• Big-Endian：高位字节存放在内存的低地址端，低位字节存放在内存的高地址端。
  MarkWord:0x00000000 00 00 00 01 ->2机制 转换结果 后三位001 无锁；hashcode采用延迟加载技术所以都是0

public class Demo {
    private static Obj obj = new Obj();
    public static void main(String[] args) {
        System.out.println(obj.hashCode());
        System.out.println(ClassLayout.parseInstance(obj).toPrintable());
    }
}

hashcode : 0x014ae5a5->10进制：21685669 与输出结果等
MarkWord: 0x014ae5a501->2进制：101001010111001011010010100000001 后三位001 无锁状态

加锁试试

public class Demo {
    private static Obj obj = new Obj();
    public static void main(String[] args) {
        synchronized (obj) {
            System.out.println(ClassLayout.parseInstance(obj).toPrintable());
        }
    }
}

MarkWord:0x029bf2d0 ->2进制：10100110111111001011010000 后两位00：轻量级锁；

对象的访问定位

创建对象自然是为了后续使用该对象，我们的Java程序会通过栈上的reference数据来操作堆上的具体对象。由于reference类型在《Java虚拟机规范》里面只规定了它是一个指向对象的引用，并没有定义这个引用通过什么方式去定位、访问到堆中对象的具体位置，所以对象访问方式也是由虚拟机实现而定的，主流的访问方式主要使用句柄和直接指针两种：

• 如果使用句柄访问的话，Java堆中将可能划分出一块内存来作为句柄池，reference中存储的就是对象的句柄地址，而句柄中包含了对象实例数据与数据类型各自具体的地址信息，如图所示.。

• 如果使用直接指针访问的话，Java堆中对象的内存布局就必须考虑如何放置访问类型数据的相关信息，reference中存储的直接就是对象地址，就不需要多一次间接访问的开销，如下图：

这两种对象访问各有优势，使用句柄来访问的最大好处就是reference中存储的是稳定句柄地址，在对象被移动（垃圾收集移动对象是非常普遍行为）时只会改变句柄中的实例数据指针，而reference本身不需要被修改

使用直接指针来访问最大的好处就是速度快，它节省来了一次指针定位的时间开销，由于对象访问在Java中非常频繁，因此这类开销积少成多也是一项极为可观的执行成本，HotSpot而言，它主要使用第二种方式进行对象访问

说明

本文章基本来自来源《深入理解Java虚拟机》第三版，文章仅做读书记录