JVM：类加载机制（类生命周期概述）_jvm类加载机制

一、类加载机制概述

        我们知道，一个 .java文件 在编译后会形成相应的一个或多个 .class文件，这些 .class文件中描述了类的各种信息，并且它们最终都需要被加载到虚拟机中才能被运行和使用。实际上，虚拟机把描述类的数据从 .class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型的过程，就是虚拟机的类加载机制。

        既然这样，那么，

• 虚拟机什么时候才会加载 .class文件并初始化类呢？（类加载和初始化时机）
• 虚拟机如何加载一个 ,class文件呢？（类加载方式：类加载器、双亲委派机制，详见JVM：类加载机制（类加载方式））
• 虚拟机加载一个 .class文件要经历哪些具体的步骤呢？（类加载过程）

二、类加载时机

        类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。其中验证、准备、解析3个部分可统称为连接（Linking），如图所示：

        了解了类的生命周期后，我们来看看第一个问题：虚拟机什么时候才会加载 .class文件并初始化类呢？

1、类加载时机

        什么情况下虚拟机需要开始加载一个类呢？加载阶段？虚拟机规范中并没有进行强制的约束，这点可以交给虚拟机的具体实现来自由把握。

2、类初始化时机

        那么，什么情况下虚拟机需要开始初始化一个类呢？这在虚拟机规范中是有严格规定了 有且只有 5中情况必须立即对类进行“初始化”（而这一过程发生在加载、验证、准备之后）：

        1) 遇到new 、getstatic、putstatic或invokestatic这4条字节码指令（）时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景由：

• 使用new关键字实例化对象的时候；
• 读取或设置类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候；
• 调用类的静态方法的时候；

        2) 使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化；

        3) 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化；

        4) 当虚拟机启动时，用户需要指定一个要执行的主类（包含 main() 方法的那个类），虚拟机会先初始化这个主类；

        5) 当使用JDK 1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化；

        注意，对于这5种会触发类进行初始化的场景，虚拟机规范中使用了一个很强烈的限定语：“有且只有”，这5种场景中的行为称为对一个类进行主动引用。除此之外，所有引用类的方式，都不会触发初始化，称为被动引用。

        特别需要指出的是，类的初始化与类的实例化是两个完全不同的概念：

• 类的初始化是指为类中各个类成员（被static修饰的成员变量）赋初始值的过程，是类生命周期中的一个阶段；
• 类的实例化是指创建一个类的实例（对象）的过程；

3、被动引用的几种经典场景

        1) 通过子类引用父类的静态字段，不会导致子类初始化

public class SuperSuperClass {

    static {
        System.out.println("SuperSuperClass init...");
    }
}

public class SuperClass extends SuperSuperClass {

    static {
        System.out.println("SuperClass init...");
    }

    public static int value = 10;
}

public class SubClass extends SuperClass {

    static {
        System.out.println("SubClass init...");
    }
}

public class NotInitialization {

    public static void main(String[] args) {
        System.out.println(SubClass.value);
    }
}
/* Output:
SuperSuperClass init...
SuperClass init...
10
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

        由上述结果所示，对于引用静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化，而不会触发子类的初始化。

        2) 通过数组定义来引用类，不会触发此类的初始化

public class NotInitialization {

    public static void main(String[] args) {
        SubClass[] arrays = new SubClass[10];
    }
}
1
2
3
4
5
6

        上述例子运行之后没有任何输出，说明虚拟机并没有初始化类SubClass。

        3) 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化

public class ConstClass {

    static {
        System.out.println("ConstClass init...");
    }

    public static final String HELLO_WORLD = "Hello World";
}

public class NotInitialization {

    public static void main(String[] args) {
        System.out.println(ConstClass.HELLO_WORLD);
    }
}
/* Output:
Hello World
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

        上述例子运行之后，只输出“Hello World”，这是因为虽然在源码中引用了ConstClass类的常量HELLO_WORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“Hello World” 存储到了NotInitialization类的常量池中，对常量ConstClass.HELLO_WORD 的引用，实际都被转化为对NotInitialization类自身常量池的引用了。

三、类加载过程

        在上文我们已提到过一个类的生命周期包括加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using) 和 卸载(Unloading)七个阶段。如下图所示：

1、加载

        在加载阶段，虚拟机需要完成以下3件事件：

        1) 通过一个类的全限定名来获取定义此类的二进制字节流；

        2) 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；

        3) 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区中这个类的各种数据访问入口；

        加载阶段与连接阶段的部分内容（如一部分字节码文件格式验证动作）是交叉进行的，加载阶段尚未完成，连接阶段可能已经开始，但这些夹在夹在阶段之中进行的动作，仍然属于连接阶段的内容，这两个阶段的开始时间仍然保持着固定的先后顺序。

2、验证

        验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。大致上会完成下面4个阶段的检验动作：

• 文件格式验证：验证字节流是否符合Class文件格式的规范（例如，是否以魔数 0xCAFEBABE开发、主次版本号是否在当前虚拟机处理范围之内、常量池的常量中是否有不支持的常量类型等）；

• 元数据验证：对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求（例如，这个类是否由父类，除了java.lang.Object之外，所有的类都应当有父类）；

• 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的；

• 符号引用验证：确保解析动作能正常执行；

        验证阶段对于虚拟机的类加载机制来说是非常重要的，但不是一定必要的，因为对程序运行期没有影响。

3、准备

        准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区进行分配。强调一下，这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在堆中。

        例如，假设一个类变量的定义为：

public static int value = 123;
1

        那么变量value在准备阶段过后的初始化值为 0 而不是 123，因为这时候尚未开始执行任何 Java方法，而 value 赋值 123 的putstatic指令是程序被编译后，存放与类构造器 <clinit>() 方法之中，所以把 value 赋值 123 的动作将在初始化阶段才会被执行。

4、解析

        解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。

        解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

5、初始化

        初始化阶段是类加载过程的最后一步。在前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与之外，其余动作完全由虚拟机主导和控制。到了初始化阶段，才真正开始执行类中定义的Java程序代码（或者说是字节码）。

        在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序猿通过程序制定的主观计划去初始化类变量和其他资源，换句话说，初始化阶段是执行类构造器 <clinit>() 方法的过程。

        <clinit>() 方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句块中可以赋值，但是不能访问，如例子所示：

public class Test {

    static {
        i = 123;
        System.out.println(i); //错误，非法向前应用
    }

    static int i = 1;
}
1
2
3
4
5
6
7
8
9

        类构造器 <clinit>() 与实例构造器 <init>() 不同，它们不需要程序猿进行显示调用，虚拟机会保证在子类类构造器 <clinit>() 执行之前，父类的类构造 <clinit>() 执行完毕。由于父类的构造器 <clinit>() 先执行，也就意味着父类中定义的静态变量、静态语句块的初始化要优先与子类的静态变量、静态语句块的初始化执行。

        虚拟机会保证一个类的类构造器()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的类构造器()，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。特别需要注意的是，在这种情形下，其他线程虽然会被阻塞，但如果执行()方法的那条线程退出后，其他线程在唤醒之后不会再次进入/执行()方法，因为 在同一个类加载器下，一个类型只会被初始化一次。如果在一个类的()方法中有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的，如下所示：

public class DealLoopTest {

    static {
        System.out.println("DealLoopTest...");
    }

    static class DeadLoopClass {

        static {
            if (true) {
                System.out.println(Thread.currentThread().getName() + " init DeadLoopClass");
                while (true) { //模拟长时间耗时操作
                }
            }
        }
    }

    public static void main(String[] args) {
        Runnable task = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName() + " start");
                DeadLoopClass deadLoopClass = new DeadLoopClass();
                System.out.println(Thread.currentThread().getName() + " end");
            }
        };

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);
        t1.start();
        t2.start();
    }
}/* Output: 
DealLoopTest...
Thread-0 start
Thread-0 init DeadLoopClass
Thread-1 start
*/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

        如上述代码所示，在初始化DeadLoopClass类时，线程Thread-1得到执行并在执行这个类的类构造器() 时，由于该方法包含一个死循环，因此久久不能退出。

四、案例分析

        我们知道，在Java中， 创建一个对象常常需要经历如下几个过程：父类的类构造器<clinit>() -> 子类的类构造器<clinit>() -> 父类的成员变量和实例代码块 -> 父类的构造函数 -> 子类的成员变量和实例代码块 -> 子类的构造函数。

        下面，我们看看程序的输出结果：

public class StaticTest {
    public static void main(String[] args) {
        staticFunction();
    }

    static StaticTest st = new StaticTest();

    static {   //静态代码块
        System.out.println("1");
    }

    {       // 实例代码块
        System.out.println("2");
    }

    StaticTest() {    // 实例构造器
        System.out.println("3");
        System.out.println("a=" + a + ",b=" + b);
    }

    public static void staticFunction() {   // 静态方法
        System.out.println("4");
    }

    int a = 110;    // 实例变量
    static int b = 112;     // 静态变量
}/* Output:
	2
	3
	a=110,b=0
	1
	4
 */
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

        大家能得到正确答案吗？虽然笔者勉强猜出了正确答案，但总感觉怪怪的。因为在初始化阶段，当JVM对类StaticTest进行初始化时，首先会执行下面的语句：

static StaticTest st = new StaticTest();
1

        也就是实例化StaticTest对象，但这个时候类都没有初始化完毕啊，能直接进行实例化吗？事实上，这涉及到一个根本问题就是：实例初始化不一定要在类初始化结束之后才开始初始化。 下面我们结合类的加载过程说明这个问题。

        我们知道，类的生命周期是：加载->验证->准备->解析->初始化->使用->卸载，并且只有在准备阶段和初始化阶段才会涉及类变量的初始化和赋值，因此我们只针对这两个阶段进行分析：

        首先，在类的准备阶段需要做的是为类变量（static变量）分配内存并设置默认值(零值)，因此在该阶段结束后，类变量st将变为null、b变为0。特别需要注意的是，如果类变量是final的，那么编译器在编译时就会为value生成ConstantValue属性，并在准备阶段虚拟机就会根据ConstantValue的设置将变量设置为指定的值。也就是说，如果上述程度对变量b采用如下定义方式时：

static final int b=112
1

        那么，在准备阶段b的值就是112，而不再是0了。

        此外，在类的初始化阶段需要做的是执行类构造器 <clinit>()，需要指出的是，类构造器本质上是编译器收集所有静态语句块和类变量的赋值语句按语句在源码中的顺序合并生成类构造器 <clinit>()。因此，对上述程序而言，JVM将先执行第一条静态变量的赋值语句：

st = new StaticTest ()
1

        此时，就碰到了笔者上面的疑惑，即“在类都没有初始化完毕之前，能直接进行实例化相应的对象吗？”。事实上，从Java角度看，我们知道一个类初始化的基本常识，那就是：在同一个类加载器下，一个类型只会被初始化一次。所以，一旦开始初始化一个类型，无论是否完成，后续都不会再重新触发该类型的初始化阶段了(只考虑在同一个类加载器下的情形)。因此，在实例化上述程序中的st变量时，实际上是把实例初始化嵌入到了静态初始化流程中，并且在上面的程序中，嵌入到了静态初始化的起始位置。这就导致了实例初始化完全发生在静态初始化之前，当然，这也是导致a为110b为0的原因。

        因此，上述程序的StaticTest类构造器 <clinit>()的实现等价于：

public class StaticTest {
    <clinit>(){
        a = 110;    // 实例变量
        System.out.println("2");        // 实例代码块
        System.out.println("3");     // 实例构造器中代码的执行
        System.out.println("a=" + a + ",b=" + b);  // 实例构造器中代码的执行
        类变量st被初始化
        System.out.println("1");        //静态代码块
        类变量b被初始化为112
    }
}
1
2
3
4
5
6
7
8
9
10
11

        因此，上述程序会有上面的输出结果。下面，我们对上述程序稍作改动，如下所示：

public class StaticTest {
    public static void main(String[] args) {
        staticFunction();
    }

    static StaticTest st = new StaticTest();

    static {
        System.out.println("1");
    }

    {
        System.out.println("2");
    }

    StaticTest() {
        System.out.println("3");
        System.out.println("a=" + a + ",b=" + b);
    }

    public static void staticFunction() {
        System.out.println("4");
    }

    int a = 110;
    static int b = 112;
    static StaticTest st1 = new StaticTest();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

        在程序最后的一行，增加以下代码行：

static StaticTest st1 = new StaticTest();
1

        那么，此时程序的输出又是什么呢？如果你对上述的内容理解很好的话，不难得出结论(只有执行完上述代码行后，StaticTest类才被初始化完成)，即：

2
3
a=110,b=0
1
2
3
a=110,b=112
4
1
2
3
4
5
6
7
8

---

引用

《深入理解Java虚拟机：JVM高级特性与最佳实践》