JVM对象探秘

本文来说下JVM中的对象

---

概述

对于 JVM 运行时区域有了一定了解以后，本文将更进一步介绍虚拟机内存中的数据的细节信息。以JVM虚拟机(Hotspot)的内存区域Java堆为例，探讨Java堆是如何创建对象、如何布局对象以及如何访问对象的。

---

对象的创建

方法	说明
使用new关键字	调用了构造函数
使用Class的newInstance方法	调用了构造函数
使用Constructor类的newInstance方法	调用了构造函数
使用clone方法	没有调用构造函数
使用反序列化	没有调用构造函数

下面举例说明五种方式的具体操作方式：

Employee.java

package cn.wideth.wechat.jvm;

import java.io.Serializable;


public class Employee implements Cloneable, Serializable {
    
    private static final long serialVersionUID = 1L;
    private String name;

    public Employee() {}

    public Employee(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((name == null) ? 0 : name.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (name == null) {
            if (other.name != null)
                return false;
        } else if (!name.equals(other.name))
            return false;
        return true;
    }

    @Override
    public String toString() {
        return "Employee [name=" + name + "]";
    }

    @Override
    public Object clone() {
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return obj;
    }
}

---

new关键字

这是最常见也是最简单的创建对象的方式了。通过这种方式，我们可以调用任意的构造函数(无参的和带参数的)。

测试程序

package cn.wideth.wechat.jvm;

public class Main {

    public static void main(String[] args) {

        Employee emp1 = new Employee();
        emp1.setName("hello");
        Employee emp2 = new Employee("world");
        System.out.println("emp1 ->" + emp1);
        System.out.println("emp2 ->" + emp2);
    }
}

程序结果

---

Class类的newInstance方法

我们也可以使用Class类的newInstance方法创建对象。这个newInstance方法调用无参的构造函数创建对象。

测试程序：

package cn.wideth.wechat.jvm;

import lombok.SneakyThrows;

public class Main {

    @SneakyThrows
    public static void main(String[] args) {

        //Class类获取对象的方式一
        Employee emp1 = (Employee) Class.forName("cn.wideth.wechat.jvm.Employee").newInstance();
        emp1.setName("上海");
        System.out.println(emp1);
        //Class类获取对象的方式二
        Employee emp2 = Employee.class.newInstance();
        emp2.setName("北京");
        System.out.println(emp2);

    }
}

程序结果

---

Constructor类的newInstance方法

和Class类的newInstance方法很像， java.lang.reflect.Constructor类里也有一个newInstance方法可以创建对象。我们可以通过这个newInstance方法调用有参数的和私有的构造函数。其中，Constructor可以从对应的Class类中获得。

测试程序

package cn.wideth.wechat.jvm;

import lombok.SneakyThrows;
import java.lang.reflect.Constructor;

public class Main {

    @SneakyThrows
    public static void main(String[] args) {

        Constructor<Employee> constructor = Employee.class.getConstructor();
        Employee emp3 = constructor.newInstance();
        emp3.setName("杭州");
        System.out.println(emp3);

    }
}

程序结果

---

Clone方法

无论何时我们调用一个对象的clone方法，JVM都会创建一个新的对象，将前面对象的内容全部拷贝进去。用clone方法创建对象并不会调用任何构造函数。

为了使用clone方法，我们需要先实现Cloneable接口并实现其定义的clone方法。

测试程序

package cn.wideth.wechat.jvm;

import lombok.SneakyThrows;
import java.lang.reflect.Constructor;

public class Main {

    @SneakyThrows
    public static void main(String[] args) {

        Constructor<Employee> constructor = Employee.class.getConstructor();
        Employee emp3 = constructor.newInstance();
        emp3.setName("杭州");
        System.out.println("emp3 ->" + emp3);
        Employee emp4 = (Employee) emp3.clone();
        System.out.println("emp4 ->" + emp4);
    }
}

程序结果

---

反序列化

当我们序列化和反序列化一个对象，JVM会给我们创建一个单独的对象。在反序列化时，JVM创建对象并不会调用任何构造函数。

为了反序列化一个对象，我们需要让我们的类实现Serializable接口。

测试程序

package cn.wideth.wechat.jvm;

import lombok.SneakyThrows;
import java.io.*;


public class Main {

    @SneakyThrows
    public static void main(String[] args) {

        Employee emp4 = new Employee();
        emp4.setName("china");
        FileOutputStream out = new FileOutputStream("D:\\a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(out);
        oos.writeObject(emp4);

        FileInputStream in = new FileInputStream("D:\\a.txt");
        ObjectInputStream ois =new ObjectInputStream(in);
        Employee emp5 = (Employee) ois.readObject();
        System.out.println("emp5 ->" + emp5);

    }
}

程序结果

---

对象的布局

HotSpot虚拟机中，对象在内存中存储的布局可以分为三块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。

---

对象头

在HotSpot虚拟机中，对象头有两部分信息组成：运行时数据 和 类型指针。

运行时数据

运行时数据 用于存储对象自身运行时的数据，如哈希码（hashCode）、GC分代年龄、线程持有的锁、偏向线程ID 等信息。

这部分数据的长度在32位和64位的虚拟机（暂不考虑开启压缩指针的场景）中分别为32个和64个Bit，官方称它为 “Mark Word”。

在32位的HotSpot虚拟机中对象未被锁定的状态下，Mark Word的32个Bit空间中的25Bit用于存储对象哈希码（HashCode），4Bit用于存储对象分代年龄，2Bits用于存储锁标志位，1Bit固定为0。

在其他状态（轻量级锁定、重量级锁定、GC标记、可偏向）下对象的存储内容如下表所示：

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

类型指针

类型指针： 指向实例对象的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例。

如果对象是一个Java数组，那在对象头中还必须有一块用于记录数组长度的数据。

---

实例数据

实例数据 部分是对象真正存储的有效信息，无论是从父类继承下来的还是该类自身的，都需要记录下来，而这部分的存储顺序受虚拟机的分配策略和定义的顺序的影响。

默认分配策略：

long/double -> int/float -> short/char -> byte/boolean -> reference

如果设置了-XX:FieldsAllocationStyle=0（默认是1），那么引用类型数据就会优先分配存储空间：

reference -> long/double -> int/float -> short/char -> byte/boolean

结论：

分配策略总是按照字节大小由大到小的顺序排列，相同字节大小的放在一起。

---

对齐填充

HotSpot虚拟机要求每个对象的起始地址必须是8字节的整数倍，也就是对象的大小必须是8字节的整数倍。而对象头部分正好是8字节的倍数（32位为1倍，64位为2倍），因此，当对象实例数据部分没有对齐的时候，就需要通过对齐填充来补全。

---

对象的访问定位

Java程序需要通过 JVM 栈上的引用访问堆中的具体对象。对象的访问方式取决于 JVM 虚拟机的实现。目前主流的访问方式有 句柄 和 直接指针 两种方式。

指针： 指向对象，代表一个对象在内存中的起始地址。
 
句柄： 可以理解为指向指针的指针，维护着对象的指针。句柄不直接指向对象，而是指向对象的指针（句柄不发生变化，指向固定内存地址），再由对象的指针指向对象的真实内存地址。

---

句柄

Java堆中划分出一块内存来作为句柄池，引用中存储对象的句柄地址，而句柄中包含了对象实例数据与对象类型数据各自的具体地址信息，具体构造如下图所示：

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

---

直接指针

如果使用直接指针访问，引用 中存储的直接就是对象地址，那么Java堆对象内部的布局中就必须考虑如何放置访问类型数据的相关信息。

优势：速度更快，节省了一次指针定位的时间开销。由于对象的访问在Java中非常频繁，因此这类开销积少成多后也是非常可观的执行成本。

---

参考

1. 周志明，深入理解Java虚拟机：
2. JVM高级特性与最佳实践，机械工业出版社

---

本文小结

本文详细介绍了JVM对象相关的知识，后面会对后续知识持续介绍。