JVM之类加载机制总结

时间 2019-11-08

标签 jvm 之类加载机制总结栏目 Java 繁體版

原文原文链接

笔试中常常碰见的题目

在系统介绍类加载机制前，咱们先看如下的代码（lz在面试题中常常会见到这种类型的题目），而后咱们在这段面试中常出现的的代码里去分析Java的类加载机制。java

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }
}    
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public static int factor = 55;

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        System.out.println("爸爸的岁数:" + Son.factor);  //入口
    }
}
复制代码

请写出代码最后的输出结果：程序员

正确答案见文章目录：初探代码面试

对于刚看到这种类型题目的同窗来讲，也许是无从下手的，若是不对Java的类加载机制有必定的了解，也许遇见屡次这种的题型仍是手足无措。bash

那么接下来就经过学习Java类加载机制的七个阶段来学会解决这种类型的题目。网络

Java类加载机制的七个阶段

加载

加载阶段是类加载过程的第一个阶段。在这个阶段，JVM 的主要目的是:将字节码从各个位置（网络、磁盘等）转化为二进制字节流加载到内存中，接着会为这个类在 JVM 的方法区建立一个对应的 Class 对象，这个 Class对象就是这个类各类数据的访问入口。函数

注: 这个过程对于解决这道题并无直接的影响，可是对于想要理解类加载机制的完整过程，这个阶段是须要了解的。学习

验证

当 JVM 加载完 Class 字节码文件并在方法区建立对应的 Class 对象以后，JVM 便会启动对该字节码流的校验，这是链接阶段的第一步，这一阶段的目的是为了确保只有符合 JVM 字节码规范的文件才能被 JVM 正确执行。spa

验证阶段大体上会完成下面4个阶段的检验动做：文件格式验证、元数据验证、字节码验证、符号引用验证。code

文件格式验证

这一阶段主要验证字节流是否符合Class文件格式的规范，而且能被当前版本虚拟机所处理。例如：cdn

①主、次版本号是否在当前虚拟机的处理范围以内；

②常量池中的常量是否有不被支持的常量类型（检查常量tag标志）；

...（等）

元数据验证

这一阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求。例如：

①这个类的父类是否继承了不容许被继承的类（被final修饰的类）；

②若是这个类不是抽象类，是否实现了其父类或接口之中要求实现的全部方法；

...(等)

字节码验证

这一阶段的主要目的是经过对数据流和控制流分析，确保程序语义是合法的，符合逻辑的。例如：

①保证跳转指令不会跳转到方法体之外的字节码指令上；

...（等）

符号引用验证

最后一个阶段的校验发生在虚拟机将符号引用转化为直接引用的时候，这个转化动做将在链接的第三阶段，解析阶段发生。符号引用验证能够看作是对类自身之外（常量池中的各类符号引用）的信息进行匹配校验。例如：

①符号引用中经过字符串描述的权限定名是否能找到对应的类；

...（等）

注: 这个过程对于解决这道题并无直接的影响，可是对于想要理解类加载机制的完整过程，这个阶段是须要了解的。

准备

当完成字节码文件的校验以后，JVM便会开始为类变量分配内存并初始化。这里须要注意两个关键点，即内存分配的对象以及初始化的类型。

内存分配的对象: Java 中的变量有「类变量」和「类成员变量」两种类型，「类变量」指的是被 static 修饰的变量，而其余全部类型的变量都属于「类成员变量」。在准备阶段，JVM 只会为「类变量」分配内存，而不会为「类成员变量」分配内存。「类成员变量」的内存分配须要等到初始化阶段才开始。例以下面的代码在准备阶段，只会为 a 属性分配内存，而不会为 b 属性分配内存。

public static int a = 3;
public String b = "java";
复制代码

初始化的类型。在准备阶段，JVM会为类变量分配内存，并为其初始化。可是这里的初始化指的是为变量赋予 Java 语言中该数据类型的零值，而不是用户代码里初始化的值。 例以下面的代码在准备阶段以后，c 的值将是 0，而不是 3。

public static int c = 3;
复制代码

但若是一个变量是常量（被 static final 修饰）的话，那么在准备阶段，属性便会被赋予用户但愿的值。例以下面的代码在准备阶段以后，number 的值将是 3，而不是 0。

public static final int number = 3;
复制代码

之因此static final 会直接被复制，而 static 变量会被赋予零值。其实咱们稍微思考一下就能想明白了。

两个语句的区别是一个有 final 关键字修饰，另一个没有。而 final 关键字在 Java 中表明不可改变的意思，意思就是说number的值一旦赋值就不会在改变了。既然一旦赋值就不会再改变，那么就必须一开始就给其赋予用户想要的值，所以被final修饰的类变量在准备阶段就会被赋予想要的值。而没有被 final修饰的类变量，其可能在初始化阶段或者运行阶段发生变化，因此就没有必要在准备阶段对它赋予用户想要的值。

解析

当经过准备阶段以后，JVM针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符 7 类引用进行解析。这个阶段的主要任务是将其在常量池中的符号引用替换成直接其在内存中的直接引用。

注：同上。

初始化

类初始化阶段是类加载过程的最后一步，这个时候用户定义的 Java 程序代码才真正开始执行。

在准备阶段，变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员的经过程序指定的主观计划去初始化类变量和其余资源，或者能够从另一个角度来表达：初始化阶段是执行类构造器<clinit>()方法的过程。<clinit>()方法执行过程当中有如下特色：

① <clinit>()方法是由编译器自动收集类中的全部类变量的赋值动做和静态语块（static{}块）中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的。例如：

public class Book {
    public static void main(String[] args)
    {
        System.out.println("Hello ShuYi.");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

    {
        System.out.println("书的普通代码块");
    }

    int price = 110;

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

    static int amount = 112;
}
复制代码

在这段代码中，<clinit>()方法就是：

static
    {
        System.out.println("书的静态代码块");
    }
    static int amount = 112;
复制代码

静态语句块只能访问到定义在静态语句块以前的变量，定义在塔以后的变量，在前面的静态语句块能够赋值，可是不能访问。

② 注意<clinit>()方法与类的构造函数（或者说实例构造器<init>()方法）不一样，它不须要显式地调用父类构造器，虚拟机会保证子类的<clinit>()方法执行以前，父类的<clinit>()方法已经执行完毕。

③因为父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句快要优先于子类的变量赋值操做。

④<clinit>()方法方法对于类或接口并非必须的，若是一个类中没有静态语句块，也没有对类变量的赋值操做，那么编译器就能够不为这个类生成<clinit>()方法。

使用

当 JVM 完成初始化阶段以后，JVM 便开始从入口方法开始执行用户的程序代码。

注：同上。

卸载

当用户程序代码执行完毕后，JVM 便开始销毁建立的 Class 对象，最后负责运行的 JVM 也退出内存。

注：同上。

初探代码

文章开头那段代码的正确结果为：

爷爷在静态代码块
爸爸在静态代码块
爸爸的岁数:55
复制代码

这里咱们观察到，咱们在Son 类中明明定义了如下静态代码块，但并无输出儿子在静态代码块

static 
    {
        System.out.println("儿子在静态代码块");
    }
复制代码

这是由于对于静态字段，只有直接定义这个字段的类才会被初始化（执行静态代码块）。就像上面的代码同样，Son的父类Father定义了factor 即：public static int factor=55;而子类Son并无定义factor的语句，因此，经过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

对面上面的这个例子，咱们能够从入口开始分析一路分析下去：

首先程序到 main 方法这里，使用标准化输出 Son 类中的 factor 类成员变量，可是 Son 类中并无定义这个类成员变量。因而往父类去找，咱们在 Father 类中找到了对应的类成员变量，因而触发了 Father 的初始化。
但根据咱们上面说到的初始化的 5 种状况中的第 2 种（当初始化一个类的时候，若是发现其父类尚未进行过初始化，则须要先触发其父类的初始化）。咱们须要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。因而咱们先初始化 Grandpa 类输出：爷爷在静态代码块，再初始化 Father 类输出：爸爸在静态代码块。
最后，全部父类都初始化完成以后，Son 类才能调用父类的静态变量，从而输出：爸爸的岁数：55。

而当咱们在Son类中一样定义factor，并赋予不同的值时，即public static int factor =66；那么最终的结果又会变为：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
爸爸的岁数:66
复制代码

Son类被初始化，并输出其静态代码块，输出的factor值是Son类中的定义的值。

再探代码

接下来再看一个升级版的例子：

class Grandpa
{
    static
    {
        System.out.println("爷爷在静态代码块");
    }

    public Grandpa() {
        System.out.println("我是爷爷~");
    }
}
class Father extends Grandpa
{
    static
    {
        System.out.println("爸爸在静态代码块");
    }

    public Father()
    {
        System.out.println("我是爸爸~");
    }
}
class Son extends Father
{
    static 
    {
        System.out.println("儿子在静态代码块");
    }

    public Son()
    {
        System.out.println("我是儿子~");
    }
}
public class InitializationDemo
{
    public static void main(String[] args)
    {
        new Son();  //入口
    }
}
复制代码

输出结果为：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
我是爷爷~
我是爸爸~
我是儿子~
复制代码

分析执行流程：

首先在入口这里咱们实例化一个 Son 对象，所以会触发 Son 类的初始化，而 Son 类的初始化又会带动 Father 、Grandpa 类的初始化，从而执行对应类中的静态代码块。所以会输出：

爷爷在静态代码块
爸爸在静态代码块
儿子在静态代码块
复制代码

当 Son 类完成初始化以后，便会调用 Son 类的构造方法，而 Son 类构造方法的调用一样会带动 Father、Grandpa 类构造方法的调用，最后会输出：

我是爷爷~
我是爸爸~
我是儿子~
复制代码

再看一个例子：

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

    static Book book = new Book();

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

    {
        System.out.println("书的普通代码块");
    }

    Book()
    {
        System.out.println("书的构造方法");
        System.out.println("price=" + price +",amount=" + amount);
    }

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

    int price = 110;
    static int amount = 112;
}
复制代码

最终结果：

书的普通代码块
书的构造方法
price=110,amount=0
书的静态代码块
书的静态方法
复制代码

分析：

在上面两个例子中，由于 main 方法所在类并无多余的代码，咱们都直接忽略了 main 方法所在类的初始化。

但在这个例子中，main 方法所在类有许多代码，咱们就并不能直接忽略了。

当 JVM 在准备阶段的时候，便会为类变量分配内存和进行初始化。此时，咱们的 book 实例变量被初始化为 null，amount 变量被初始化为 0。当进入初始化阶段后，由于 Book 方法是程序的入口，由于当虚拟机启动时，用户须要指定一个要执行的主类（包含main()方法的那个类，虚拟机会先初始化这个主类，因此JVM 会初始化 Book 类，即执行类构造器。
JVM 对 Book 类进行初始化首先是执行类构造器（按顺序收集类中全部静态代码块和类变量赋值语句就组成了类构造器后执行对象的构造器（按顺序收集成员变量赋值和普通代码块，最后收集对象构造器，最终组成对象构造器）

对于 Book 类，其类构造方法（）能够简单表示以下：

static Book book = new Book();
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;
复制代码

因而首先执行static Book book = new Book();这一条语句，这条语句又触发了类的实例化。因而 JVM 执行对象构造器，收集后的对象构造器代码：

{
    System.out.println("书的普通代码块");
}
int price = 110;
Book()
{
    System.out.println("书的构造方法");
    System.out.println("price=" + price +", amount=" + amount);
}
复制代码

因而此时 price 赋予 110 的值，输出：

书的普通代码块
书的构造方法
复制代码

而此时 price 为 110 的值，而 amount 的赋值语句并未执行，因此只有在准备阶段赋予的零值，因此以后输出price=110,amount=0

当类实例化完成以后，JVM 继续进行类构造器的初始化：

static Book book = new Book();  //完成类实例化
static
{
    System.out.println("书的静态代码块");
}
static int amount = 112;
复制代码

即输出：书的静态代码块，以后对 amount 赋予 112 的值。

到这里，类的初始化已经完成，JVM 执行 main 方法的内容。

public static void main(String[] args)
{
    staticFunction();
}
复制代码

即输出：书的静态方法

总结

从上面几个例子能够看出，分析一个类的执行顺序大概能够按照以下步骤：

肯定类变量的初始值。在类加载的准备阶段，JVM会为类变量初始化零值，这时候类变量会有一个初始的零值。若是是被 final 修饰的类变量，则直接会被初始成用户想要的值。
初始化入口方法。当进入类加载的初始化阶段后，JVM 会寻找整个 main 方法入口，从而初始化 main 方法所在的整个类。当须要对一个类进行初始化时，会首先初始化类构造器（），以后初始化对象构造器（）。
初始化类构造器。JVM 会按顺序收集类变量的赋值语句、静态代码块，最终组成类构造器由 JVM 执行。
初始化对象构造器。JVM 会按照收集成员变量的赋值语句、普通代码块，最后收集构造方法，将它们组成对象构造器，最终由 JVM 执行。

若是在初始化 main 方法所在类的时候遇到了其余类的初始化，那么就先加载对应的类，加载完成以后返回。如此反复循环，最终返回 main 方法所在类。

原文出处

周志明：《深刻理解Java虚拟机》
陈树义：两道面试题，带你解析Java类加载机制

JVM之类加载机制总结

笔试中常常碰见的题目

Java类加载机制的七个阶段

加载

验证

准备

解析

初始化

使用

卸载

初探代码

再探代码

总结

原文出处