第 9 章一对象的实例化步骤、对象头信息(重点)、对象访问定位

「爱情、让人受尽委屈。」 2022-12-29 00:16 117阅读 0赞

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

![image-20200709152801713][]

## 1、对象的实例化 ##

> **大厂面试题**

**美团：**

*  对象在`JVM`中是怎么存储的？
 *  `对象头`信息里面有哪些东西？

**蚂蚁金服：**

*  二面：`java`对象头里有什么

> **对象实例化**

![image-20200709095356247][]

### 1.1、对象创建的方式 ###

> **对象创建的方式**

*  `new`：最常见的方式、`单例类`中**调用getInstance的静态类方法**，**XXXFactory的静态方法**

1.  `Class的newInstance方法`：在JDK9里面被标记为过时的方法，因为只能调用空参构造器，并且权限必须为 public
2.  `Constructor的newInstance(Xxxx)`：反射的方式，可以调用空参的，或者带参的构造器
3.  `使用clone()`：不调用任何的构造器，**要求当前的类需要实现Cloneable接口中的clone方法**
4.  `使用序列化`：**序列化一般用于Socket的网络传输 (二进制流 转为 实体对象)**
5.  第三方库 Objenesis

### 1.2、对象创建的步骤 (`重点`) ###

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

*  代码

/** * @author shkstart shkstart@126.com * @create 2020 17:16 */
    public class ObjectTest { 
        public static void main(String[] args) { 
            Object obj = new Object();
        }
    }

*  main() 方法对应的字节码（后面细讲）：
    
     *  调用 `new 指令`后后，**加载 Object 类**
     *  调用`Object 类的 init() 方法`

0 new #2 <java/lang/Object>
    3 dup
    4 invokespecial #1 <java/lang/Object.<init>>
    7 astore_1
    8 return

> **创建对象的步骤**
> 
>  *  ① 加载类元信息 (存储在方法区中)
>  *  ② 为对象分配内存
>  *  ③ 处理并发问题
>  *  ④ 属性的默认初始化（零值初始化）
>  *  **⑤ 设置对象头的信息**
>  *  ⑥ 属性的显式初始化、代码块中初始化、构造器中初始化

##### **1、首先判断对象对应的`类是否加载、链接、初始化`** #####

>  *  当JVM遇到`new`指令, 首先去`元空间的运行时常量池`中查找有没有要创建的这个类的`符号引用`, 并检查该符号引用的类是否已经`加载、链接、初始化 (判断该类的Class信息是否存在)`
>  *  如果`该类没有加载`, 此时在`双亲委派模式`下, 去加载该类, 在加载该类的`字节码`时, 会先以`ClassLoader + 包名 + 类名`作为`key`去找`.class`文件, 如果没有, 则报`ClassNotFoundException`异常. 如果找到对应的class字节码文件, 则进行加载,生成对应的Class对象。

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

--------------------

##### **2、`为对象分配内存`** #####

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

##### **3、处理并发问题** #####

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

##### **4、为对象属性设置默认值, 分配到内存** #####

*  `所有属性设置默认值`，**保证对象实例字段在不赋值可以直接使用**

##### **5、设置对象的对象头** #####

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

##### **6、执行`init方法进行初始化`** #####

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

回顾给对象属性赋值的顺序：

*  属性的默认值初始化
 *  显示初始化/代码块初始化（并列关系，谁先谁后看代码编写的顺序）
 *  构造器初始化

--------------------

> **从字节码角度看 init 方法**

*  代码

/** * 测试对象实例化的过程 * ① 加载类元信息 - ② 为对象分配内存 - ③ 处理并发问题 - ④ 属性的默认初始化（零值初始化） * - ⑤ 设置对象头的信息 - ⑥ 属性的显式初始化、代码块中初始化、构造器中初始化 * * * 给对象的属性赋值的操作： * ① 属性的默认初始化 - ② 显式初始化 / ③ 代码块中初始化 - ④ 构造器中初始化 * @author shkstart shkstart@126.com * @create 2020 17:58 */
    
    public class Customer{ 
        int id = 1001;
        String name;
        Account acct;
    
        { 
            name = "匿名客户";
        }
        
        public Customer(){ 
            acct = new Account();
        }
    
    }
    class Account{ 
    
    }

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

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

## 2、对象的内存布局 ##

> **对象内存布局**

![image-20200709151033237][]

### 2.1、对象头 `(重点)` ###

> **对象头**

**对象头包含两部分：`运行时元数据（Mark Word）`和`类型指针 (Klass Word)`**

1.  **`运行时元数据`**
    
     *  `哈希值（HashCode）`，可以看作是**堆中对象的地址**
     *  `GC分代年龄（年龄计数器）`
     *  锁状态标志
     *  线程持有的锁
     *  偏向线程ID
     *  偏向时间戳
2.  **`类型指针`**
    
     *  指向`类元数据InstanceKlass，确定该对象所属的类型`。指向的其实是**方法区中存放的类元信息**

说明：如果对象是数组，还需要记录数组的长度

### 2.2、实例数据 ###

> **实例数据（Instance Data）**

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

### 2.3、对齐填充 ###

> **对齐填充**

不是必须的，也没特别含义，仅仅起到占位符的作用

> **内存布局总结**

*  代码

public class Customer{ 
        int id = 1001;
        String name;
        Account acct;
    
        { 
            name = "匿名客户";
        }
        public Customer(){ 
            acct = new Account();
        }
    
    }
    class Account{ 
    }
    
    public class ObjectTest { 
        public static void main(String[] args) { 
            Object obj = new Object();
        }
    }

*  图解内存布局

![image-20200709152801713][]

## 3、对象的访问定位 ##

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

![image-20200709164149920][]  
![image-20200729205948530][]

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

**1、句柄访问**

1.  缺点：**在堆空间中开辟了一块空间作为句柄池，句柄池本身也会占用空间；通过两次指针访问才能访问到堆中的对象，** **效率低**
2.  优点：reference中存储稳定句柄地址，`对象被移动（垃圾收集时移动对象很普遍）时只会改变句柄中实例数据指针`即可，`reference本身不需要被修改`

![image-20200709164342002][]

--------------------

**2、`直接指针（HotSpot采用）`**

1.  优点：**直接指针是局部变量表中的引用，直接指向堆中的实例，** 在对象实例中有`类型指针`，指向的是`方法区中的对象类型数据`
2.  缺点：**对象被移动（垃圾收集时移动对象很普遍）时需要修改 reference 的值**

![image-20200709164350466][]

[image-20200709152801713]: /images/20221120/d2281ae3034c45ca9275e842e7fb526d.png
[image-20200709095356247]: /images/20221120/77be4f40f41249f7b8580bb13e1b4b51.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L20wXzM3OTg5OTgw_size_16_color_FFFFFF_t_70]: /images/20221120/1adb5c4a0f854f729b68ae9acec18b07.png
[image-20200709151033237]: /images/20221120/8fbf32e1137047e1b8bc3f2f27704a9f.png
[image-20200709164149920]: /images/20221120/27641ffb130447ed8cc018d2811bbb57.png
[image-20200729205948530]: /images/20221120/0acae46131c045a7b44f9cb099c6c572.png
[image-20200709164342002]: /images/20221120/e838c00dee344ec89048645a87321515.png
[image-20200709164350466]: /images/20221120/f4253ba6e2ef419091fbc28a2f1f1540.png