JVM类生命周期概述：加载时机与加载过程

朱雀 2023-08-17 17:08 57阅读 0赞

一个.java文件在编译后会形成相应的一个或多个Class文件，这些Class文件中描述了类的各种信息，并且它们最终都需要被加载到虚拟机中才能被运行和使用。事实上，虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验，转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型的过程就是虚拟机的类加载机制。本文概述了JVM加载类的时机和生命周期，并结合典型案例重点介绍了类的初始化过程，进而了解JVM类加载机制。

## 一、类加载机制概述 ##

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

与那些在编译时需要进行连接工作的语言不同，在Java语言里面，类型的加载和连接都是在程序运行期间完成，这样会在类加载时稍微增加一些性能开销，但是却能为Java应用程序提供高度的灵活性，Java中天生可以动态扩展的语言特性多态就是依赖运行期动态加载和动态链接这个特点实现的。例如，如果编写一个使用接口的应用程序，可以等到运行时再指定其实际的实现。这种组装应用程序的方式广泛应用于Java程序之中。

既然这样，那么，

*  虚拟机什么时候才会加载Class文件并初始化类呢？（类加载和初始化时机）
 *  虚拟机如何加载一个Class文件呢？（Java类加载的方式：类加载器、双亲委派机制）
 *  虚拟机加载一个Class文件要经历那些具体的步骤呢？（类加载过程/步骤）

本文主要对第一个和第三个问题进行阐述。

--------------------

## 二. 类加载的时机　 ##

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

![1408728-20190815175410185-982408436.png][]

加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。以下陈述的内容都已HotSpot为基准。特别需要注意的是，类的加载过程必须按照这种顺序按部就班地“开始”，而不是按部就班的“进行”或“完成”，因为这些阶段通常都是相互交叉地混合式进行的，也就是说通常会在一个阶段执行的过程中调用或激活另外一个阶段。

了解了Java类的生命周期以后，那么我们现在来回答第一个问题：虚拟机什么时候才会加载Class文件并初始化类呢？

**1、类加载时机**

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

**2、类初始化时机**

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

1) 遇到new、getstatic、putstatic或invokestatic这四条字节码指令（注意，newarray指令触发的只是数组类型本身的初始化，而不会导致其相关类型的初始化，比如，new String\[\]只会直接触发String\[\]类的初始化，也就是触发对类\[Ljava.lang.String的初始化，而直接不会触发String类的初始化）时，如果类没有进行过初始化，则需要先对其进行初始化。生成这四条指令的最常见的Java代码场景是：

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

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

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

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

5) 当使用jdk1.7动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF\_getstatic,REF\_putstatic,REF\_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行初始化，则需要先出触发其初始化。

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

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

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

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

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

public class SSClass{
        static{
            System.out.println("SSClass");
        }
    }  
    
    public class SClass extends SSClass{
        static{
            System.out.println("SClass init!");
        }
    
        public static int value = 123;
    
        public SClass(){
            System.out.println("init SClass");
        }
    }
    
    public class SubClass extends SClass{
        static{
            System.out.println("SubClass init");
        }
    
        static int a;
    
        public SubClass(){
            System.out.println("init SubClass");
        }
    }
    
    public class NotInitialization{
        public static void main(String[] args){
            System.out.println(SubClass.value);
        }
    }
    /* Output: 
            SSClass
            SClass init!
            123     
     */

对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。在本例中，由于value字段是在类SClass中定义的，因此该类会被初始化；此外，在初始化类SClass时，虚拟机会发现其父类SSClass还未被初始化，因此虚拟机将先初始化父类SSClass，然后初始化子类SClass，而SubClass始终不会被初始化。

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

public class NotInitialization{
        public static void main(String[] args){
            SClass[] sca = new SClass[10];
        }
    }

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

public class ConstClass{
    
        static{
            System.out.println("ConstClass init!");
        }
    
        public static  final String CONSTANT = "hello world";
    }
    
    public class NotInitialization{
        public static void main(String[] args){
            System.out.println(ConstClass.CONSTANT);
        }
    }
    /* Output: 
            hello world
     */

上述代码运行之后，只输出 “hello world”，这是因为虽然在Java源码中引用了ConstClass类中的常量CONSTANT，但是编译阶段将此常量的值“hello world”存储到了NotInitialization常量池中，对常量ConstClass.CONSTANT的引用实际都被转化为NotInitialization类对自身常量池的引用了。也就是说，实际上NotInitialization的Class文件之中并没有ConstClass类的符号引用入口，这两个类在编译为Class文件之后就不存在关系了。

--------------------

## 三. 类加载过程 ##

如上图所示，我们在上文已经提到过一个类的生命周期包括加载（Loading）、验证（Verification）、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Using) 和 卸载(Unloading)七个阶段。现在我们一一学习一下JVM在加载、验证、准备、解析和初始化五个阶段是如何对每个类进行操作的。  
**1、加载**

加载是类加载过程中的一个阶段， 这个阶段会在内存中生成一个代表这个类的 java.lang.Class 对象， 作为方法区这个类的各种数据的入口。注意这里不一定非得要从一个 Class 文件获取，这里既可以从 ZIP 包中读取（比如从 jar 包和 war 包中读取），也可以在运行时计算生成（动态代理），也可以由其它文件生成（比如将 JSP 文件转换成对应的 Class 类）。

**2、验证**

**　**　这一阶段的主要目的是为了**确保 Class 文件的字节流中包含的信息是否符合当前虚拟机的要求，并****且不会危害虚拟机自身的安全。**

**3、准备**

**　　**准备阶段是正式为类变量分配内存并设置类变量的初始值阶段，即在方法区中分配这些变量所使用的内存空间。注意这里所说的初始值概念，比如一个类变量定义为

public static int v = 8080;

实际上变量 v 在准备阶段过后的初始值为 0 而不是 8080， 将 v 赋值为 8080 的 put static 指令是程序被编译后， 存放于类构造器<client>方法之中。但是注意如果声明为

public static final int v = 8080；

在编译阶段会为 v 生成 ConstantValue 属性，在准备阶段虚拟机会根据 ConstantValue 属性将 v赋值为 8080。

**4、解析**

解析阶段是指虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是 class 文件中的：

1. CONSTANT\_Class\_info

2. CONSTANT\_Field\_info

3. CONSTANT\_Method\_info等类型的常量。* *

**4.1 符号引用**

符号引用与虚拟机实现的布局无关， 引用的目标并不一定要已经加载到内存中。 各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须是一致的，因为符号引用的字面量形式明确定义在 Java 虚拟机规范的 Class 文件格式中

** 4.2 直接引用**

直接引用可以是指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。如果有了直接引用，那引用的目标必定已经在内存中存在。

**5、初始化**

初始化阶段是类加载最后一个阶段，前面的类加载阶段之后，除了在加载阶段可以自定义类加载器以外，其它操作都由 JVM 主导。到了初始阶段，才开始真正执行类中定义的 Java 程序代码 。初始化阶段是执行类构造器<client>方法的过程。 <client>方法是由编译器自动收集类中的类变量的赋值操作和静态语句块中的语句合并而成的。虚拟机会保证子<client>方法执行之前，父类的<client>方法已经执行完毕， 如果一个类中没有对静态变量赋值也没有静态语句块，那么编译器可以不为这个类生成<client>()方法

注意以下几种情况不会执行类初始化：

1. 通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。  
　　2. 定义对象数组，不会触发该类的初始化。  
　　3. 常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触  
　　   发定义常量所在的类。  
　　4. 通过类名获取 Class 对象，不会触发类的初始化。  
　　5. 通过 Class.forName 加载指定类时，如果指定参数 initialize 为 false 时，也不会触发类初  
　　　始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。  
　　6. 通过 ClassLoader 默认的 loadClass 方法，也不会触发初始化动作。

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

public class DealLoopTest {
        static{
            System.out.println("DealLoopTest...");
        }
        static class DeadLoopClass {
            static {
                if (true) {
                    System.out.println(Thread.currentThread()
                            + "init DeadLoopClass");
                    while (true) {      // 模拟耗时很长的操作
                    }
                }
            }
        }
    
        public static void main(String[] args) {
            Runnable script = new Runnable() {   // 匿名内部类
                public void run() {
                    System.out.println(Thread.currentThread() + " start");
                    DeadLoopClass dlc = new DeadLoopClass();
                    System.out.println(Thread.currentThread() + " run over");
                }
            };
    
            Thread thread1 = new Thread(script);
            Thread thread2 = new Thread(script);
            thread1.start();
            thread2.start();
        }
    }
    /* Output: 
            DealLoopTest...
            Thread[Thread-1,5,main] start
            Thread[Thread-0,5,main] start
            Thread[Thread-1,5,main]init DeadLoopClass
     */

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

--------------------

## 四. 典型案例分析　　 ##

在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
     */

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

static StaticTest st = new StaticTest();

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

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

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

static final int b=112

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

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

st = new StaticTest ()；

在类都没有初始化完毕之前，能直接进行实例化相应的对象吗？

事实上，从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
        }
    }

因此，上述程序会有上面的输出结果。下面，我们对上述程序稍作改动，在程序最后的一行，增加以下代码行：

static StaticTest st1 = new StaticTest();

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

2
    3
    a=110,b=0
    1
    2
    3
    a=110,b=112
    4

那么下面的程序的执行结果是什么呢？？？

class Foo {
        int i = 1;
    
        Foo() {
            System.out.println(i);             
            int x = getValue();
            System.out.println(x);            
        }
    
        {
            i = 2;
        }
    
        protected int getValue() {
            return i;
        }
    }
    
    //子类
    class Bar extends Foo {
        int j = 1;
    
        Bar() {
            j = 2;
        }
    
        {
            j = 3;
        }
    
        @Override
        protected int getValue() {
            return j;
        }
    }
    
    public class ConstructorExample {
        public static void main(String... args) {
            Bar bar = new Bar();
            System.out.println(bar.getValue());        
        }
    }

在创建对象前，先进行类的初始化，类的初始化会将所有非静态代码块收集起来先执行，而父类必须先于子类初始化，所以父类静态代码块先执行，接着是子类静态代码块。此时类初始化完成。接下来要创建子类实例，子类通过super()调用父类构造方法，在执行构造方法之前要先执行非静态代码块，所以顺序是 父类非静态代码块 》 父类构造函数 》 子类非静态代码块 》 子类构造函数

运行程序，就知道结果。只要真正理解类的实例化过程，这类问题不会再难道我们了！

转载于:https://www.cnblogs.com/Young111/p/11359700.html

[1408728-20190815175410185-982408436.png]: /images/20230808/92f34bc95cd34f4ab2701bdf58a975ca.png