【性能】Java对象生命周期

Java对象生命周期

对象的生命周期大致可以分为7个阶段：

• 创建阶段（Created）
• 应用阶段（Using）
• 不可视阶段（Invisible）
• 不可达阶段（Unreachable）
• 可收集阶段（Collected）
• 终结阶段（Finalized）
• 对象空间重新分配（Deallocated）

创建阶段（Created）

在对象创建阶段，一般要经历以下几个步骤才能完成对象的创建过程：

1. 为对象分配存储空间
2. 开始构造对象
3. 从超类到该对象的类对static成员进行初始化，类的static成员的初始化在ClassLoader加载该类时进行
4. 超类成员按变量顺序初始化，递归调用超类的构造方法
5. 对象的类成员变量按顺序初始化

上述的第4个步骤，就是指递归调用该类所扩展的所有父类的构造方法，一个Java类（除Object外）至少有一个父类（Object），这个规则既是强制也是隐式的。在创建对象时，应该遵循一些基本规则，以提高应用性能
（1）避免在循环体中创建对象，即使该对象占用内存空间不大
（2）尽量及时使对象符合垃圾回收标准
（3）不要采用过深的继承层次
（4）访问本地变量优于访问类中的变量

在这里，说明一下一个概念：

Person person1 = new Person()

new Person()称为对象的实例化过程，new出来的Person()是对象，person1是对象的引用，Person person1是对象引用的声明。网上很多乱七八糟的称呼，觉得有必要说明一下。

关于避免在循环体中创建对象，举个例子：

for(int i=0;i<100;i++){
	Object obj = new Object();
	...
}

我们都知道，对象被存放在堆上¹，栈里面是一个一个栈帧，每个栈帧对应一次方法的调用。栈帧中存放了局部变量表，局部变量表中存放着对象的引用。所以，对象的引用在栈中。上述for循环，每次循环都会创建一个对象，存放在堆中，并且创建一个对象的引用存放在栈帧的局部变量表中，浪费了很多资源，因为上述写法，共创建了100份对象，100份对象引用，如果将对象引用的声明放在for循环外边，如下所示：

Object obj = null;
for(int i = 0 ; i < 100 ; i++ ){
	obj = new Object();
	...
}

上述方法仅保存了一份对象的引用，减少了系统开销，节约了内存。

一旦对象被创建，并被分派给某些变量赋值，完成后这个对象的状态就切换到了应用阶段。

应用阶段（Using）

至少被一个强引用持有着，关于强引用，可参考文章：Java中的四种引用：强引用、软引用、弱引用和虚引用

不可见阶段（Invisible）

即使有强引用持有对象，但是这些强引用对于程序来说是不能访问的，就会进入这个阶段（非必须经历阶段），如：

public void run() {
    try {
        Object foo = new Object();
        foo.doSomething();
    } catch (Exception e) {
        // whatever
    }
    while (true) { // do stuff } // loop forever
}

Java虚拟机栈，也是线程的私有空间，它和Java线程在同一时间创建²。run是一个方法，它被调用时存放在虚拟机栈的栈帧中，对象的引用foo存放在栈的局部变量表中，即GC root（虚拟机栈）到foo引用对象之间是可达的，所以foo所指向的对象无法被释放，foo的引用也无法被回收。但该对象是在try块中被创建，对于while来说是不可被访问的，此时的对象就是不可见对象。

注：new出来的Object是对象（存放在堆中），foo是Object对象的引用（存放在栈的局部变量表中）。

不可达阶段（Unreachable）

对象处于不可达阶段是指该对象不再被任何由GC root的强引用的引用链可达的状态。GC root一般有：

• 虚拟机栈中引用的对象
• 类静态变量引用的对象
• JNI的native方法栈中农引用的对象
• JNI的global对象
• 活着的线程

虚拟机栈中的每个栈帧对应一个方法调用，栈帧中的局部变量表里保存着对应方法的局部变量。试想一下，如果这些正在执行的方法中局部变量引用着的对象被回收了，这个线程还能正常运行吗？native 方法栈也是同理。另外，方法运行时，随时都可能会访问到类中的静态变量以及常量，这些类肯定也是不能被回收的，JNI global 对象也是同理。当然还有一些没有列举到的根对象类型³。

举个循环引用的例子来说明

public void buildDog() {
   Dog newDog = new Dog();
   Tail newTail = new Tail();
   newDog.tail = newTail;
   newTail.dog = newDog;
}

如下图所示，Dog与Tail相互引用，并且两者都是方法的局部变量，方法存放在虚拟机栈中，当方法没有return前，虚拟机栈（GC root）到Dog与Tail之间都是可达的

当buildDog return后，之前占用的栈帧就消失了，虽然Dog和Tail相互强引用，但是它们都没有被GC root（虚拟机栈）强引用，所以到GC root之间没有可达路径，所以成为待回收对象，如下图所示：

收集阶段（Collected）

当垃圾回收器发现该对象已经处于“不可达阶段”并且垃圾回收器已经对该对象的内存空间重新分配做好准备时，对象进入“收集阶段”。如果该对象已经重写了finalize()方法，并且没有被执行过，则执行该方法（finalize方法）的操作。否则直接进入终结阶段。

终结阶段（Finalized）

当对象执行完finalize()方法后仍然处于不可达状态时，该对象进入终结阶段。在该阶段，等待垃圾回收器回收该对象空间。

重新分配阶段（Deallocated）

如果在完成上述所有工作完成后对象仍不可达，则垃圾回收器对该对象的所占用的内存空间进行回收或者再分配，该对象彻底消失。

---

1. Java8虚拟机内存模型 ↩︎

2. 一文捋清Java虚拟机内存模型 ↩︎

3. Java对象生命周期 ↩︎