JAVA进阶（3）—— 类的生命周期

类的生命周期

java类的生命周期就是指一个class文件从加载到卸载的全过程。
完整的生命周期会经历加载、连接、初始化、使用、和卸载五个阶段，当然也有在加载或者连接之后没有被初始化就直接被使用的情况，如图所示：

类的生命周期

加载

在java中，我们经常会接触到一个词——类加载，它和这里的加载并不是一回事，通常我们说类加载指的是类的生命周期中加载、连接、初始化三个阶段。在加载阶段，找到需要加载的类并把类的信息加载到方法区中，然后在堆区中实例化一个java.lang.Class对象，作为方法区中这个类的信息的入口。对于加载的时机，真正用到一个类的时候才对它进行加载。有时连接阶段并不会等加载阶段完全完成之后才开始，而是交叉进行，加载阶段总是在连接阶段之前开始，连接阶段总是在加载阶段完成之后完成。

连接

连接阶段比较复杂，一般会跟加载阶段和初始化阶段交叉进行，可以细分为三个步骤：验证、准备和解析。

验证

当一个类被加载之后，必须要验证一下这个类是否合法，保证加载的类是能够被jvm所运行。比如这个类是不是符合字节码的
格式、变量与方法是不是有重复、数据类型是不是有效、继承与实现是否合乎标准等等。

准备

准备阶段的工作就是为类的静态变量分配内存并设为jvm默认的初值，对于非静态的变量，则不会为它们分配内存。有一点需要注意，这时候，静态变量的初值为jvm默认的初值，而不是我们在程序中设定的初值。jvm默认的初值是这样的：基本类型（int、long、short、char、byte、boolean、float、double）的默认值为0，引用类型的默认值为null。常量的默认值为我们程序中设定的值，比如我们在程序中定义final static int a = 100，则准备阶段中a的初值就是100。

解析

这一阶段的任务就是把常量池中的符号引用转换为直接引用。那么什么是符号引用，什么又是直接引用呢？比如我们要在内存中找一个类里面的一个叫做show的方法，显然是找不到。但是在解析阶段，jvm就会把show这个名字转换为指向方法区的的一块内存地址， jvm会将所有的类或接口名、字段名、方法名转换为具体的内存地址。

初始化

直接引用

会触发类的初始化。在java中，直接引用的情况有：

• 通过new关键字实例化对象、读取或设置类的静态变量、调用类的静态方法。
• 通过反射方式执行以上三种行为。
• 初始化子类的时候，会触发父类的初始化。
• 作为程序入口直接运行时（也就是直接调用main方法）。

被动引用

除了以上四种情况，其他使用类的方式叫做被动引用，而被动引用不会触发类的初始化。

• 引用父类的静态字段，只会引起父类的初始化，而不会引起子类的初始化。
• 定义类数组，不会引起类的初始化。
• 引用类的常量，不会引起类的初始化。

示例代码：

import java.lang.reflect.Field;
import java.lang.reflect.Method;
class InitClass{
    static {
        System.out.println("初始化InitClass");
    }
    public static String a = null;
    public static void method(){}
}

class SubInitClass extends InitClass{}

public class Test1 {

    /**
     * 主动引用引起类的初始化的第四种情况就是运行Test1的main方法时
     * 导致Test1初始化，这一点很好理解，就不特别演示了。
     * 本代码演示了前三种情况，以下代码都会引起InitClass的初始化，
     * 但由于初始化只会进行一次，运行时请将注解去掉，依次运行查看结果。
     * @param args
     * @throws Exception
     */
    public static void main(String[] args) throws Exception{
        //  主动引用引起类的初始化一: new对象、读取或设置类的静态变量、调用类的静态方法。
        //  new InitClass();
        //  InitClass.a = "";
        //  String a = InitClass.a;
        //  InitClass.method();

        //  主动引用引起类的初始化二：通过反射实例化对象、
        //  读取或设置类的静态变量、调用类的静态方法。
        //  Class cls = InitClass.class;
        //  cls.newInstance();

        //  Field f = cls.getDeclaredField("a");
        //  f.get(null);
        //  f.set(null, "s");

        //  Method md = cls.getDeclaredMethod("method");
        //  md.invoke(null, null);

        //  主动引用引起类的初始化三：实例化子类，引起父类初始化。
        //  new SubInitClass();

    }
}   

类的初始化过程

先看一个例子：

public class Insect {
    private int i = 9;
    protected int j ;
    private int x2 = printInt("Inset.x2 init\n");
    public Insect() {
        System.out.print("i=" + i + ",j = " + j +"\n");
        j=39;
    }
    private int x3 = printInt("Inset.x3 init\n"); 
    static {
        System.out.print("父类静态代码块初始化\n");
    }
    {
        System.out.print("父类代码块初始化\n");
    }
    private static int x1 = printInt("Inset.x1 init\n"); 
            
    static int printInt(String s) {
        System.out.print(s);
        return 47;
    }        
}

public class Beetle extends Insect {
    private int k = printInt("Beetle.k init\n");
    private int x3 = printInt("Beetle.x3 is init\n");

    public Beetle() {
        System.out.print("s=" + s + ",");
        System.out.print("k=" + k + ",");
        System.out.print("j=" + j);
    }

    static {
        System.out.print("子类静态代码块初始化\n");
    }
    {
        System.out.print("子类代码块初始化\n");
    }
    private int x4 = printInt("Beetle.x4 is init\n");
    private static int x2 = printInt("Beetle.x2 is init\n");

    private int s = printInt("Beetle.s init\n");

    /**
     * @param args
     */
    public static void main(String[] args) {
        System.out.print("Starting\n");
        Beetle b = new Beetle();// 情況1
        int a = Beetle.x2;// 情況2
    }
}

情况1运行结果：

父类静态代码块初始化
Inset.x1 init
子类静态代码块初始化
Beetle.x2 is init
Starting
Inset.x2 init
Inset.x3 init
父类代码块初始化
i=9,j = 0
Beetle.k init
Beetle.x3 is init
子类代码块初始化
Beetle.x4 is init
Beetle.s init
s=47,k=47,j=39

情况2运行结果：

父类静态代码块初始化
Inset.x1 init
子类静态代码块初始化
Beetle.x2 is init
Starting

结论：

• 在非实例化对象的初始化，只会初始化与类相关的静态赋值语句和静态语句，也就是有static关键字修饰的。
• 没有static修饰的赋值语句和执行语句在实例化对象的时候才会运行。
• 首先会顺序初始化父类初始化static 变量 或者 静态初始化块，然后子类
  顺序初始化父类普通变量 或者 父类普通变量初始化块 ，然后是构造函数
  顺序初始化子类普通变量 或者 子类普通变量初始化块 ，然后是构造函数

使用

类的使用包括主动引用和被动引用
示例代码：

class InitClass{
    static {
        System.out.println("初始化InitClass");
    }
    public static String a = null;
    public final static String b = "b";
    public static void method(){}
}

class SubInitClass extends InitClass{
    static {
        System.out.println("初始化SubInitClass");
    }
}

public class Test4 {
    public static void main(String[] args) throws Exception{
        //  String a = InitClass.a;// 引用父类的静态字段，只会引起父类初始化 
        //  String b = InitClass.b;// 使用类的常量不会引起类的初始化  
        SubInitClass[] sc = new SubInitClass[10];// 定义类数组不会引起类的初始化  
    }
}

卸载

在类使用完之后，如果满足下面的情况，类就会被卸载：

• 该类所有的实例都已经被回收，也就是java堆中不存在该类的任何实例。
• 加载该类的ClassLoader已经被回收。
• 该类对应的java.lang.Class对象没有任何地方被引用，无法在任何地方通过反射访问该类的方法。
  如果以上三个条件全部满足，jvm就会在方法区垃圾回收的时候对类进行卸载。
  类的卸载过程其实就是在方法区中清空类信息，java类的整个生命周期就结束了。

总结

对于对象的生命周期大家可能都比较熟悉，对象基本上都是在jvm的堆区中创建，在创建对象之前，会触发类加载（加载、连接、初始化），当类初始化完成后，根据类信息在堆区中实例化类对象，初始化非静态变量、非静态代码以及默认构造方法，当对象使用完之后会在合适的时候被jvm垃圾收集器回收。读完本文后我们知道，对象的生命周期只是类的生命周期中使用阶段的主动引用的一种情况（即实例化类对象）。而类的整个生命周期则要比对象的生命周期长的多。

参考文献

详解java类的生命周期