概述

上一节分析了类加载时会把class文件中静态数据结构(包括常量池、方法表(方法字节码指令)、字段表等)转化为方法区的运行时数据结构，本节继续分析new背后的后续流程；本节主要以下面两个类为例进行分析

public class User {
    public static int money = 99;
    private String name;
    private int age = 3;
    public User(String name) {
        this.name = name;
    }
}

public class Demo {
    public void tests(String a){
        int temp = 1;
        User user = new User("zzzliu");
    }
}

运行时数据模型.png

1. 'new'指令执行

--tests方法字节码反汇编信息：
public void tests(java.lang.String);
    descriptor: (Ljava/lang/String;)V
    flags: ACC_PUBLIC
    Code:
      stack=3, locals=4, args_size=2
         0: iconst_1
         1: istore_2
         2: new           #2                  // class zzzliu/JVM/User
         5: dup
         6: ldc           #3                  // String zzzliu
         8: invokespecial #4                  // Method zzzliu/JVM/User."<init>":(Ljava/lang/String;)V
        11: astore_3
        12: return
      LineNumberTable:
        line 6: 0
        line 7: 2
        line 8: 12
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      13     0  this   Lzzzliu/JVM/Demo;
            0      13     1     a   Ljava/lang/String;
            2      11     2  temp   I
           12       1     3  user   Lzzzliu/JVM/User;

JVM解释执行tests方法时，会先在当前线程栈中组建一个tests方法的栈帧(如上图<运行时数据模型.png>中栈所示)
找到方法区Demo.class中tests字节码指令，并开始执行(忽略前两条指令)
a. 2 new #2 <zzzliu/JVM/User>创建User实例对象，然后把实例引用压到tests操作数栈顶
b. 5 dup复制栈顶User引用并压入栈顶(此时栈顶有两个User引用)
c. 6 ldc #3 <zzzliu>把字符串'zzzliu'从字符串常量池推送至栈顶
d. 8: invokespecial #4执行User实例<init>方法(需要开辟新栈帧，图中没画)
e. 11: astore_3User实例创建成功，把引用写到局部变量表slot3位置，即将user指向分配的内存空间

注意：invokespecial指令(执行构造方法初始化实例变量)和astore指令(将user指向分配的内存空间，此时user已经不为null)有可能发生指令重排序，导致多线程时其他线程有可能拿到不为null但是实例变量尚未赋值的对象; 这也就是DCL单例时为什么要用volatile防止指令重排序的原因

2. 内存分配

内存分配主要涉及三个问题 1. 需要分配多大内存？2. 在哪儿分配？3. 如何分配

2.1 对象占用内存大小计算

对象组成.png

对象由3部分组成：对象头(下面详解)、实例数据、对齐填充
实例数据部分存放对象实例字段数据，static字段在方法区创建实例对象时不用分配内存
对齐填充要保证对象整体连续内存大小为8的整数倍,让字段只出现在同一 CPU 的缓存行中,防止跨缓存行的字段同时污染两个缓存行

User实例内存大小计算

涉及到的压缩指针、字段重排列、虚共享问题后期单独分析

2.2 在哪儿分配？

对象首先尝试在TLAB进行分配，无法分配时再尝试在共享堆中分配

TLAB：为每一个线程预先在Eden区分配一块内存，JVM在给线程中的对象分配内存时，首先在TLAB分配，当对象大于TLAB中的剩余内存或TLAB的内存已用尽时，再采用下述的CAS进行内存分配
CAS+失败重试 ：虚拟机采用 CAS 配上失败重试的方式保证更新内存指针操作的原子性

具体分配在Eden区、Survivor-From区、Survivor-From区、老年代、还是Region本节先不分析

2.3 如何分配？

由于JVM使用垃圾收集器不同决定了使用不同的GC算法，不同的GC算法决定了不同的内存形态，不同的内存形态又决定了不同的分配方式

指针碰撞：新生代垃圾收集器一般采用‘标记-复制’算法，及老年代采用‘标记-整理’算法(例如Serial Old、Parallel Old)时内存是规整的，不存在内存碎片，可以直接通过指针的移动分配内存
空闲列表：老年代采用'标记-清除'算法(例如CMS)时是JVM维护空闲列表用来记录剩余的可分配内存空间，每次分配内存后动态维护这个列表

3. 初始化零值

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

注意：JVM不会给局部变量赋零值，因此局部变量不显示赋值编译器会报错

4. 设置对象头

初始化零值完成之后，虚拟机要对对象进行必要的设置，例如这个对象是那个类的实例、如何才能找到类的元数据信息、对象的哈希吗、对象的 GC 分代年龄等信息
对象头主要由三部分组成

MarkWord: 64位JVM占用8字节
MetaData: 指向方法区class对象的指针，开启压缩指针占4字节未开启占8字节(Hotspot默认开启)
ArrayLength: 数组长度，数组类型才有，占用4字节

MarkWord主要跟锁相关，具体细节参考第一篇文件[synchronized锁升级详细过程]

64位Hotspot对象头MarkWord

5. 执行<init>方法

至此从虚拟机的视角来看，一个新的对象已经产生了，但从Java程序的视角来看，所有的字段都还为零，无法使用。需要执行<init>方法初始化后，这样一个真正可用的对象才算完全创建出来；

5.1 <init>字节码指令执行

public static int money;
  descriptor: I
  flags: ACC_PUBLIC, ACC_STATIC

private java.lang.String name;
  descriptor: Ljava/lang/String;
  flags: ACC_PRIVATE

private int age;
  descriptor: I
  flags: ACC_PRIVATE

--User <init>方法
public zzzliu.JVM.User(java.lang.String);
  descriptor: (Ljava/lang/String;)V
  flags: ACC_PUBLIC
  Code:
    stack=2, locals=2, args_size=2
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: aload_0
       5: iconst_3
       6: putfield      #2                  // Field age:I
       9: aload_0
      10: aload_1
      11: putfield      #3                  // Field name:Ljava/lang/String;
      14: return
    LocalVariableTable:
      Start  Length  Slot  Name   Signature
          0      15     0  this   Lzzzliu/JVM/User;
          0      15     1  name   Ljava/lang/String;

0 aload_0: 局部变量表slot0位置(this引用)压栈
1 invokespecial #1: 执行父类(Object)<init>方法
4 aload_0: 局部变量表slot0位置(this引用)压栈
5 iconst_3: 常量3加载到操作数栈
6 putfield #2 <zzzliu/JVM/User.age>: 常量池第2项age赋值3
9 aload_0: 局部变量表slot0位置(this引用)压栈
10 aload_1: 局部变量表slot1位置(字符串zzzliu引用)压栈
11 putfield #3 <zzzliu/JVM/User.name>: 常量池第3项name的符号引用指向zzzliu在堆内实际内存地址
14 return: 当前方法运行结束，返回上一栈帧

5.2 <init>和<clinit>区别

clinit是类构造器方法，在类加载中的初始化阶段由JVM自动调用，对静态变量/静态代码块进行初始化
init是对象构造器方法，没有自定义构造方法时JVM会自动生成一个无参构造方法，内部调用父类<init>方法，对非静态变量进行初始化

--clinit方法字节码指令：
static {};
    descriptor: ()V
    flags: ACC_STATIC
    Code:
      stack=1, locals=0, args_size=0
         0: bipush        99
         2: putstatic     #4                  // Field money:I
         5: return
      LineNumberTable:
        line 4: 0

0: bipush 99: 将常量99加载到操作数栈
2: putstatic #4 // Field money:I: 常量池第4项money赋值99
5: return: 当前方法运行结束，返回上一栈帧

总结

new对象主要分5个步骤：类加载 - 分配内存 - 初始化零值 - 设置对象头 - 执行构造方法

--------over---------

3. new背后发生了什么-对象创建