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

  • 时间:
  • 浏览:13

  有一个多多.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)七个阶段。其中准备、验证、解析有一个次责统称为连接(Linking),如图所示:

  加载、验证、准备、初始化和卸载这个个阶段的顺序是选者 的,类的加载过程可不要都可不可以了按照一种顺序按部就班地结束,而解析阶段则不一定:它在要是 情况下可不要都可不可以在初始化阶段以前再结束,这是为了支持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采用如下定义最好的办法时:

 这样,在准备阶段b的值好多好多 112,而不再是0了。

  此外,在类的初始化阶段可不要都可不可以了做的是执行类构造器<clinit>(),可不要都可不可以了指出的是,类构造器本质上是编译器分发所有静态搞笑的话块和类变量的赋值搞笑的话按搞笑的话在源码中的顺序合并生成类构造器<clinit>()。要是,对上述多多进程 而言,JVM将先执行第四根静态变量的赋值搞笑的话:

  在类都这样初始化完毕以前,能直接进行实例化相应的对象吗?

  事实上,从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()调用父类构造最好的办法,在执行构造最好的办法以可不要都可不可以了先执行非静态代码块,好多好多 顺序是 父类非静态代码块 》 父类构造函数 》 子类非静态代码块 》 子类构造函数

运行多多进程 ,就知道结果。假若真正理解类的实例化过程,类似于大问题不要再难道没这样人了!