9.1 🧛‍♂️对象实例化

📷思维导图

image.png

⌨️对象创建五大方式

实体类：

  1. package top.parak.easy;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Data;
  5. import lombok.NoArgsConstructor;
  6. import java.io.Serializable;
  7. import java.util.Date;
  9. @Data 
  10. @AllArgsConstructor 
  11. @NoArgsConstructor 
  12. public class DemoData implements Serializable, Cloneable { 
  14.     private String stringData; 
  15.     private Date dateData; 
  16.     private Integer intData; 
  17.     private Double douData; 
  19.     @Override 
  20.     protected Object clone() throws CloneNotSupportedException { 
  21.         return super.clone(); 
  22.     } 
  23. }

测试：

  1. @org.junit.Test
  2. public void testClass() throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, CloneNotSupportedException, IOException {
  3.     // 1 new
  4.     DemoData demoData1 = new DemoData("1-start", new Date(), 1, 0.1);
  5.     System.out.println(demoData1.toString());
  7.     // 2 反射
  8.     Class<?> clazz = Class.forName("top.parak.easy.DemoData");
  9.     // 使用Class.newInstance()创建
  10.     DemoData demoData2 = (DemoData) clazz.newInstance();
  11.     demoData2.setStringData("2-start");
  12.     demoData2.setDateData(new Date());
  13.     demoData2.setIntData(2);
  14.     demoData2.setDouData(0.2);
  15.     System.out.println(demoData2.toString());
  16.     // 使用Constructor.newInstance()创建
  17.     Constructor<?> constructor = clazz.getDeclaredConstructor(String.class, Date.class, Integer.class, Double.class);
  18.     DemoData demoData3 = (DemoData) constructor.newInstance("3-start", new Date(), 3, 0.3);
  19.     System.out.println(demoData3.toString());
  21.     // 3 clone
  22.     DemoData demoData4 = (DemoData) demoData1.clone();
  23.     demoData4.setStringData("4-start");
  24.     demoData4.setIntData(4);
  25.     demoData4.setDouData(0.4);
  26.     System.out.println(demoData4.toString());
  28.     // 4 Serializable
  29.     ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("data.ser"));
  30.     objectOutputStream.writeObject(demoData1);
  31.     objectOutputStream.close();
  32.     ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("data.ser"));
  33.     DemoData demoData5 = (DemoData) objectInputStream.readObject();
  34.     demoData5.setStringData("5-start");
  35.     demoData5.setIntData(5);
  36.     demoData5.setDouData(0.5);
  37.     System.out.println(demoData5.toString());
  38. }

结果：

  1. DemoData(stringData=1-start, dateData=Tue Dec 15 20:23:31 CST 2020, intData=1, douData=0.1)
  2. DemoData(stringData=2-start, dateData=Tue Dec 15 20:23:31 CST 2020, intData=2, douData=0.2)
  3. DemoData(stringData=3-start, dateData=Tue Dec 15 20:23:31 CST 2020, intData=3, douData=0.3)
  4. DemoData(stringData=4-start, dateData=Tue Dec 15 20:23:31 CST 2020, intData=4, douData=0.4)
  5. DemoData(stringData=5-start, dateData=Tue Dec 15 20:23:31 CST 2020, intData=5, douData=0.5)

🎨对象创建六大步骤

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

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

（2）为对象分配内存

首先计算对象占用空间的大小，接着在堆中划分一块内存给新对象。如果实例成员变量是引用变量，仅分配引用变量空间即可，即4个字节。

如果内存规整：指针碰撞。

如果内存不规整：虚拟机需要维护一个列表，空闲列表。

如果内存是规整的，那么虚拟机将采用指针碰撞法（Bump The Point）来为对象分配内存。意思是所有用过的内存在一边，空闲的内存放另外一边，中间放着一个指针作为分界点的指示器，分配内存就仅仅是把指针指向空闲那边挪动一段与对象大小相等的距离罢了。如果垃圾收集器选择的是Serial，ParNew这种基于压缩算法的，虚拟机采用这种分配方式。一般使用带Compact（整理）过程的收集器时，使用指针碰撞。

如果内存是不规整的，已使用内存和未使用的内存相互交错，那么虚拟机将采用的是空闲列表来为对象分配内存。意思是虚拟机维护了一个列表，记录 上那些内存块是可用的，再分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的内容。这种分配方式称为“空闲列表”。

选择哪种分配方式由Java堆是否规整所决定，而Java堆是否规整又由所采用的垃圾收集器是否带有压缩整理功能决定。

（3）处理并发安全问题

在分配内存空间时，另外一个问题是及时保证new对象时候的线程安全性：创建对象是非常长频繁的操作，虚拟机需要解决并发问题。虚拟机采用两种方式解决并发问题：

  • CAS(Compare And Swap)失败重试 、区域加锁：保证指针更新操作的原子性；
  • 每个线程预先分配一块TLAB(本地线程分配缓冲区)，是否使用TLAB通过-XX:+/-UseTLAB参数来设定。

（4）初始化分配到的空间

内存分配结束，虚拟机将分配到的内存空间都初始化为零值。这一步保证了对象的实例字段在Java代码中可以不用赋初始值就可以直接使用，程序能访问到这些字段的数据类型所对应的零值。

给对象属性赋值的操作：

  • 属性的默认初始化
  • 显示初始化
  • 代码块中的初始化
  • 构造器初始化
  • 所有属性设置默认值，保证对象实例字段在不赋值的情况下可以直接使用

（5）设置对象的对象头

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

（6）执行init方法进行初始化

在Java程序的视角来看，初始化才正式开始。初始化成员变量，执行实例化代码块，调用类的构造方法，并把堆内对象的首地址复制给引用变量。

因此一般来说（由字节码中跟随invokespecial指令所决定），new指令之后就是执行方法，把对象按照程序员的意愿进行初始化，这样一个真正可用的对象才算完整创建出来。

9.2 🔳 对象内存布局

📷思维导图

image.png

普通对象 Object Header（64 bits）

Mark Word（32 bits） Class Pointer（32 bits）

数组对象 Object Header（96 bits）

Mark Word（32 bits） Class Pointer（32 bits） Array length（32 bits）

其中Mark Word结构，在正常无锁状态下：

hashcode （25 bits） gc age（4 bits） biased_lock （1 bits） lock state （2 bits）

9.3 🛰️ 对象访问定位

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

image-20210307115251686.png

1️⃣句柄访问

栈的局部变量表中，记录的对象的引用，然后在堆空间中开辟了一块空间，也就是句柄池。

优点：reference中存储稳定句柄地址，对象被移动（垃圾收集时移动对象很普遍）时只会改变句柄中实例数据指针即可，reference本身不需要被修改。

image-20210307120509642.png

2️⃣直接指针

直接指针是局部变量表中的引用，直接指向堆中的实例，在对象实例中有类型指针，指向的是方法区中的对象类型数据。

好处：节省空间，速度更快。

image-20210307120911877.png