第九章-对象的实例化内存布局与访问定位

JVM java jvm
发布时间 :
字数:2.9k 阅读 : 评论:
  1. 环境
  2. 一、对象的实例化
    1. 1. 对象创建的方式
    2. 2. 对象创建的步骤
      1. 2.1 判断对象对应的类是否加载、链接、初始化
      2. 2.2 为对象分配内存
      3. 2.3 处理并发问题
      4. 2.4 初始化分配到的空间
      5. 2.5 设置对象的对象头
      6. 2.6 执行init方法进行初始化
        1. 2.6.1 从字节码角度看 init 方法
  3. 二、对象的内存布局
    1. 1. 对象头(Header)
    2. 2. 实例数据(Instance Data)
    3. 3. 对齐填充(Padding)
  4. 三、对象的访问定位
    1. 1. 句柄访问
    2. 2. 直接指针（HotSpot采用）
      1. 参考链接

环境

系统 : Windows 10
JDK : 1.8

一、对象的实例化

对象的实例化

1. 对象创建的方式

  • new：最常见的方式、单例类中调用getInstance的静态类方法，XxxBuilder/XxxFactory的静态方法
  • Class的newInstance方法：在JDK9里面被标记为过时的方法，因为只能调用空参构造器，并且权限必须为 public
  • Constructor的newInstance(Xxxx)：反射的方式，可以调用空参的，或者带参的构造器
  • 使用clone()：不调用任何的构造器，要求当前的类需要实现Cloneable接口中的clone方法
  • 使用序列化：从文件中，从网络中获取一个对象的二进制流，序列化一般用于Socket的网络传输
  • 第三方库 Objenesis

2. 对象创建的步骤

从字节码看待对象的创建过程

Java代码

public class ObjectTest {
    public static void main(String[] args) {
        Object obj = new Object();
    }
}

字节码

Classfile /H:/code_test/JVMDemo/out/production/chapter10/com/atguigu/java/ObjectTest.class
  Last modified 2023-11-28; size 456 bytes     
  MD5 checksum 04a948734154e10697a376f964f07df1
  Compiled from "ObjectTest.java"
public class com.atguigu.java.ObjectTest       
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #2.#19         // java/lang/Object."<init>":()V
   #2 = Class              #20            // java/lang/Object
   #3 = Class              #21            // com/atguigu/java/ObjectTest
   #4 = Utf8               <init>
   #5 = Utf8               ()V
   #6 = Utf8               Code
   #7 = Utf8               LineNumberTable
   #8 = Utf8               LocalVariableTable
   #9 = Utf8               this
  #10 = Utf8               Lcom/atguigu/java/ObjectTest;
  #11 = Utf8               main
  #12 = Utf8               ([Ljava/lang/String;)V
  #13 = Utf8               args
  #14 = Utf8               [Ljava/lang/String;
  #15 = Utf8               obj
  #16 = Utf8               Ljava/lang/Object;
  #17 = Utf8               SourceFile
  #18 = Utf8               ObjectTest.java
  #19 = NameAndType        #4:#5          // "<init>":()V
  #20 = Utf8               java/lang/Object
  #21 = Utf8               com/atguigu/java/ObjectTest
{
  public com.atguigu.java.ObjectTest();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 7: 0
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       5     0  this   Lcom/atguigu/java/ObjectTest;

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: new           #2                  // class java/lang/Object
         3: dup
         4: invokespecial #1                  // Method java/lang/Object."<init>":()V
         7: astore_1
         8: return
      LineNumberTable:
        line 9: 0
        line 10: 8
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0       9     0  args   [Ljava/lang/String;
            8       1     1   obj   Ljava/lang/Object;
}
SourceFile: "ObjectTest.java"

2.1 判断对象对应的类是否加载、链接、初始化

  • 虚拟机遇到一条new指令，首先去检查这个指令的参数能否在Metaspace的常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已经被加载，解析和初始化。（即判断类元信息是否存在）。
  • 如果该类没有加载，那么在双亲委派模式下，使用当前类加载器以ClassLoader + 包名 + 类名为key进行查找对应的.class文件，如果没有找到文件，则抛出ClassNotFoundException异常，如果找到，则进行类加载，并生成对应的Class对象。

2.2 为对象分配内存

  • 首先计算对象占用空间的大小，接着在堆中划分一块内存给新对象。如果实例成员变量是引用变量，仅分配引用变量空间即可，即4个字节大小
  • 如果内存规整：采用指针碰撞分配内存
    • 如果内存是规整的，那么虚拟机将采用的是指针碰撞法（Bump The Point）来为对象分配内存。
    • 意思是所有用过的内存在一边，空闲的内存放另外一边，中间放着一个指针作为分界点的指示器，分配内存就仅仅是把指针往空闲内存那边挪动一段与对象大小相等的距离罢了。
    • 如果垃圾收集器选择的是Serial ，ParNew这种基于压缩算法的，虚拟机采用这种分配方式。一般使用带Compact（整理）过程的收集器时，使用指针碰撞。
    • 标记压缩（整理）算法会整理内存碎片，堆内存一存对象，另一边为空闲区域
  • 如果内存不规整
    • 如果内存不是规整的，已使用的内存和未使用的内存相互交错，那么虚拟机将采用的是空闲列表来为对象分配内存。
    • 意思是虚拟机维护了一个列表，记录上哪些内存块是可用的，再分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的内容。这种分配方式成为了 “空闲列表（Free List）”
    • 选择哪种分配方式由Java堆是否规整所决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定
    • 标记清除算法清理过后的堆内存，就会存在很多内存碎片。

2.3 处理并发问题

  • 采用CAS+失败重试保证更新的原子性
  • 每个线程预先分配TLAB - 通过设置 -XX:+UseTLAB 参数来设置（区域加锁机制）
  • 在Eden区给每个线程分配一块区域

2.4 初始化分配到的空间

  • 所有属性设置默认值，保证对象实例字段在不赋值可以直接使用。
  • 给对象属性赋值的顺序：
    • 属性的默认值初始化
    • 显示初始化/代码块初始化（并列关系，谁先谁后看代码编写的顺序）
    • 构造器初始化

2.5 设置对象的对象头

将对象的所属类（即类的元数据信息）、对象的HashCode和对象的GC信息、锁信息等数据存储在对象的对象头中。这个过程的具体设置方式取决于JVM实现。

2.6 执行init方法进行初始化

  • 在Java程序的视角看来，初始化才正式开始。初始化成员变量，执行实例化代码块，调用类的构造方法，并把堆内对象的首地址赋值给引用变量
  • 因此一般来说（由字节码中跟随invokespecial指令所决定），new指令之后会接着就是执行init方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完成创建出来。

2.6.1 从字节码角度看 init 方法

Java代码

/**
 * 测试对象实例化的过程
 *  ① 加载类元信息 - ② 为对象分配内存 - ③ 处理并发问题  - ④ 属性的默认初始化（零值初始化）
 *  - ⑤ 设置对象头的信息 - ⑥ 属性的显式初始化、代码块中初始化、构造器中初始化
 *
 *  给对象的属性赋值的操作：
 *  ① 属性的默认初始化 - ② 显式初始化 / ③ 代码块中初始化 - ④ 构造器中初始化
 */

public class Customer{
    int id = 1001;
    String name;
    Account acct;

    {
        name = "匿名客户";
    }
    public Customer(){
        acct = new Account();
    }

}
class Account{

}

Customer类的字节码

 0 aload_0
 1 invokespecial #1 <java/lang/Object.<init> : ()V>
 4 aload_0
 5 sipush 1001
 8 putfield #2 <com/atguigu/java/Customer.id : I>
11 aload_0
12 ldc #3 <匿名客户>
14 putfield #4 <com/atguigu/java/Customer.name : Ljava/lang/String;>
17 aload_0
18 new #5 <com/atguigu/java/Account>
21 dup
22 invokespecial #6 <com/atguigu/java/Account.<init> : ()V>
25 putfield #7 <com/atguigu/java/Customer.acct : Lcom/atguigu/java/Account;>
28 return

image-20231220213215486

  • init() 方法的字节码指令
    • 属性的默认值初始化：id = 1001;
    • 显示初始化/代码块初始化：name = "匿名客户";
    • 构造器初始化：acct = new Account();

二、对象的内存布局

内存布局

对象内存布局

1. 对象头(Header)

包含两部分：运行时元数据(Mark Word)、类型指针

  • 运行时元数据
    • 哈希值 (HashCode)
    • GC分代年龄
    • 锁状态标志
    • 线程持有的锁
    • 偏向线程ID
    • 偏向时间戳
  • 指向类元数据InstanceKlass，确定该对象所属的类型
  • 说明:如果是数组，还需记录数组的长度

2. 实例数据(Instance Data)

  • 说明：它是对象真正存储的有效信息，包括程序代码中定义的各种类型的字段(包括从父类继承下来的和本身拥有的字段)
  • 规则
    • 相同宽度的字段总是被分配在一起
    • 父类中定义的变量会出现在子类之前
    • 如果CompactFields参数为true(默认为true): 子类的窄变量可能插入到父类变量的空隙

进一步了解实例数据和指针压缩，看这篇博客：https://blog.csdn.net/qq_41929714/article/details/131421540

3. 对齐填充(Padding)

  • 为了保证对象的大小为8字节的整数倍。将对象头和实例数据的大小相加，以8为倍数向上补齐就是这个对象的大小。即：对象头+实例数据=30，则对齐填充，向上取8的倍数进行补齐，就是32，这个对象大小就是32。
  • 不是必须的，也没特别含义，仅仅起到占位符的作用

代码示例

public class Customer{
    int id = 1001;
    String name;
    Account acct;

    {
        name = "匿名客户";
    }
    public Customer(){
        acct = new Account();
    }

}
class Account{

}

图示对象的内存布局

三、对象的访问定位

JVM是如何通过栈帧中的对象引用访问到其内部的对象实例呢？

答案：通过栈上reference访问

image-20231221125332865

对象的两种访问方式：句柄访问和直接指针

1. 句柄访问

句柄访问

使用句柄访问对象，首先要了解句柄池是在堆中开辟的一块内存空间作为句柄池，句柄池中有很多很多的句柄，每个句柄之间又包含了：

  • 指向对象实例的指针：储存了对象实例数据，即属性值结构体的内存地址，对象实例数据一般也在heap中开辟。
  • 指向对象类型数据的指针：访问类型数据的内存地址(类信息，方法类型信息)，对象类型数据一般储存在方法区中。

当局部变量表中的引用类型reference指向句柄池，并且定位到句柄池中间目标对象的句柄，然后再根据该句柄中的句柄信息，找到对象。

  • 优点：reference存储的是稳定的句柄地址，在对象被移动(垃圾收集时移动对象是非常普遍的行为)时只会改变句柄中的实例数据指针，而reference本身不需要改变。

  • 缺点：在堆空间中开辟了一块空间作为句柄池，句柄池本身也会占用空间；通过两次指针访问才能访问到堆中的对象，即会有两次IO操作，效率低

2. 直接指针（HotSpot采用）

使用直接指针访问

直接指针访问方式，局部变量表中的引用类型reference指向对象实例数据，对象实例数据中需要有额外的内存开销需要用来存放指向对象类型数据的指针(来存放对象在方法区的类信息地址)，也就是需要开辟出一个额外的空间来存放，这个空间就是Class Pointer。

  • 优点： 节省了一次指针定位的开销。即只有一次IO操作，比句柄池访问对象快一倍。
  • 缺点： 在对象被移动时(如进行GC后的内存重新排列)，reference本身需要被修改。

hotsport用的就是直接指针访问的方式。对象的引用实际上就是对对象的直接引用，也称为指针。当我们声明一个引用变量时，它实际上是指向对象的指针。

直接指针访问的方式是一种典型的空间换时间的方式，而hotsport大部分场景下用的都是这种场景。

参考链接

https://blog.csdn.net/qq_41929714/article/details/131421540

转载请注明来源，欢迎对文章中的引用来源进行考证，欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论，也可以邮件至 george_95@126.com

©2016-2020 George

Built with Hexo and 3-hexo theme