关于jvm调优:面试之加分项JVM-类加载机制

当 Java 虚拟机将 Java 源码编译为字节码之后，虚拟机便能够将字节码读取进内存，从而进行解析、运行等整个过程.。

这个过程咱们叫：Java 虚拟机的类加载机制。JVM 虚拟机执行 class 字节码的过程能够分为七个阶段：加载 、 验证 、 筹备 、 解析 、 初始化 、 应用 、 卸载。

在开始聊之前，先给大家看一道面试题。

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

    public static int factor = 25;

    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);    // 入口
    }
}

请写出最初的输入字符串。

正确答案是：

爷爷在动态代码块
爸爸在动态代码块
爸爸的岁数:25

我置信很多同学看到这个题目之后，表情是解体的，齐全不晓得从何动手。有的甚至遇到了几次，依然无奈找到正确的解答思路。

其实这种面试题考查的就是你对 Java 类加载机制的了解。如果你对 Java 加载机制不了解，那么你是无奈解答这道题目的。这篇文章，我将通过对 Java 类加载机制的解说，让你把握解答此类题目的办法。

上面是对于加载过程最为官网的形容。

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

其实加载阶段用一句话来说就是：把代码数据加载到内存中。这个过程对于咱们解答这道问题没有间接的关系，但这是类加载机制的一个过程，所以必须要提一下。

当 JVM 加载完 Class 字节码文件并在办法区创立对应的 Class 对象之后，JVM 便会启动对该字节码流的校验，只有合乎 JVM 字节码标准的文件能力被 JVM 正确执行。这个校验过程大抵能够分为上面几个类型：

JVM 标准校验。JVM 会对字节流进行文件格式校验，判断其是否合乎 JVM 标准，是否能被以后版本的虚拟机解决。例如：文件是否是以 0x cafe bene 结尾，主次版本号是否在以后虚拟机解决范畴之内等。
- 代码逻辑校验。JVM 会对代码组成的数据流和控制流进行校验，确保 JVM 运行该字节码文件后不会呈现致命谬误。例如一个办法要求传入 int 类型的参数，然而应用它的时候却传入了一个 String 类型的参数。一个办法要求返回 String 类型的后果，然而最初却没有返回后果。代码中援用了一个名为 Apple 的类，然而你实际上却没有定义 Apple 类。

当代码数据被加载到内存中后，虚拟机就会对代码数据进行校验，看看这份代码是不是真的依照 JVM 标准去写的。这个过程对于咱们解答问题也没有间接的关系，然而理解类加载机制必须要晓得有这个过程。

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

内存调配的对象。Java 中的变量有「类变量」和「类成员变量」两种类型，「类变量」指的是被 static 润饰的变量，而其余所有类型的变量都属于「类成员变量」。在筹备阶段，JVM 只会为「类变量」分配内存，而不会为「类成员变量」分配内存。「类成员变量」的内存调配须要等到初始化阶段才开始。
例如上面的代码在筹备阶段，只会为 factor 属性分配内存，而不会为 website 属性分配内存。

public static int factor = 3;
public String website = "www.cnblogs.com/chanshuyi";

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

public static int sector = 3;

但如果一个变量是常量（被 static final 润饰）的话，那么在筹备阶段，属性便会被赋予用户心愿的值。例如上面的代码在筹备阶段之后，number 的值将是 3，而不是 0。

public static final int number = 3;

之所以 static final 会间接被复制，而 static 变量会被赋予零值。其实咱们略微思考一下就能想明确了。

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

当通过筹备阶段之后，JVM 针对类或接口、字段、类办法、接口办法、办法类型、办法句柄和调用点限定符 7 类援用进行解析。这个阶段的次要工作是将其在常量池中的符号援用替换成间接其在内存中的间接援用。

其实这个阶段对于咱们来说也是简直通明的，理解一下就好。

初始化（重点）
到了初始化阶段，用户定义的 Java 程序代码才真正开始执行。在这个阶段，JVM 会依据语句执行程序对类对象进行初始化，一般来说当 JVM 遇到上面 5 种状况的时候会触发初始化：

遇到 new、getstatic、putstatic、invokestatic 这四条字节码指令时，如果类没有进行过初始化，则须要先触发其初始化。生成这 4 条指令的最常见的 Java 代码场景是：应用 new 关键字实例化对象的时候、读取或设置一个类的动态字段（被 final 润饰、已在编译器把后果放入常量池的动态字段除外）的时候，以及调用一个类的静态方法的时候。

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

当初始化一个类的时候，如果发现其父类还没有进行过初始化，则须要先触发其父类的初始化。
当虚拟机启动时，用户须要指定一个要执行的主类（蕴含 main()办法的那个类），虚构机会先初始化这个主类。
当应用 JDK1.7 动静语言反对时，如果一个 java.lang.invoke.MethodHandle 实例最初的解析后果 REF_getstatic,REF_putstatic,REF_invokeStatic 的办法句柄，并且这个办法句柄所对应的类没有进行初始化，则须要先出触发其初始化。

看到下面几个条件你可能会晕了，然而不要紧，不须要背，晓得一下就好，前面用到的时候回到找一下就能够了。

当 JVM 实现初始化阶段之后，JVM 便开始从入口办法开始执行用户的程序代码。这个阶段也只是理解一下就能够。

当用户程序代码执行结束后，JVM 便开始销毁创立的 Class 对象，最初负责运行的 JVM 也退出内存。这个阶段也只是理解一下就能够。

看完了 Java 的类加载机智之后，是不是有点懵呢。不怕，咱们先通过一个小例子来醒醒神。

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
    {// 退出 Java 开发交换君样：756584822 一起吹水聊天
        System.out.println("书的动态代码块");
    }

    static int amount = 112;
}

思考一下下面这段代码输入什么？

给你 5 分钟思考，5 分钟后交卷，哈哈。

怎么样，想好了吗，颁布答案了。

书的动态代码块

Hello ShuYi.

怎么样，你答对了吗？是不是和你想得有点不一样呢。

上面咱们来简略剖析一下，首先依据下面说到的触发初始化的 5 种状况的第 4 种（当虚拟机启动时，用户须要指定一个要执行的主类（蕴含 main()办法的那个类），虚构机会先初始化这个主类），咱们会进行类的初始化。

那么类的初始化程序到底是怎么样的呢？

重点来了！

在咱们代码中，咱们只晓得有一个构造方法，但实际上 Java 代码编译成字节码之后，是没有构造方法的概念的，只有类初始化办法和对象初始化办法。

那么这两个办法是怎么来的呢？

类初始化办法。编译器会依照其呈现程序，收集类变量的赋值语句、动态代码块，最终组成类初始化办法。类初始化办法个别在类初始化的时候执行。
下面的这个例子，其类初始化办法就是上面这段代码了：

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

对象初始化办法。编译器会依照其呈现程序，收集成员变量的赋值语句、一般代码块，最初收集构造函数的代码，最终组成对象初始化办法。对象初始化办法个别在实例化类对象的时候执行。
下面这个例子，其对象初始化办法就是上面这段代码了：

    {System.out.println("书的一般代码块");
    }// 退出 Java 开发交换君样：756584822 一起吹水聊天
    int price = 110;
    System.out.println("书的构造方法");
    System.out.println("price=" + price +",amount=" + amount);

类初始化办法和对象初始化办法之后，咱们再来看这个例子，咱们就不难得出下面的答案了。

但仔细的敌人肯定会发现，其实下面的这个例子其实没有执行对象初始化办法。

因为咱们的确没有进行 Book 类对象的实例化。如果你在 main 办法中减少 new Book() 语句，你会发现对象的初始化办法执行了！

感兴趣的敌人能够本人入手试一下，我这里就不执行了。

通过了下面的实践和简略例子，咱们上面进入更加简单的实战剖析吧！

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

    public static int factor = 25;

    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 开发交换君样：756584822 一起吹水聊天
}

思考一下，下面的代码最初的输入后果是什么？

最终的输入后果是：

爷爷在动态代码块
爸爸在动态代码块
爸爸的岁数:25

兴许会有人问为什么没有输入「儿子在动态代码块」这个字符串？

这是因为对于动态字段，只有间接定义这个字段的类才会被初始化（执行动态代码块）。因而通过其子类来援用父类中定义的动态字段，只会触发父类的初始化而不会触发子类的初始化。

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

首先程序到 main 办法这里，应用标准化输入 Son 类中的 factor 类成员变量，然而 Son 类中并没有定义这个类成员变量。于是往父类去找，咱们在 Father 类中找到了对应的类成员变量，于是触发了 Father 的初始化。

但依据咱们下面说到的初始化的 5 种状况中的第 3 种（当初始化一个类的时候，如果发现其父类还没有进行过初始化，则须要先触发其父类的初始化）。咱们须要先初始化 Father 类的父类，也就是先初始化 Grandpa 类再初始化 Father 类。

于是咱们先初始化 Grandpa 类输入：「爷爷在动态代码块」，再初始化 Father 类输入：「爸爸在动态代码块」。
最初，所有父类都初始化实现之后，Son 类能力调用父类的动态变量，从而输入：「爸爸的岁数：25」。

怎么样，是不是感觉恍然大悟呢。

咱们再来看一下一个更简单点的例子，看看输入后果是啥。

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)
    {// 退出 Java 开发交换君样：756584822 一起吹水聊天
        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);
    }// 退出 Java 开发交换君样：756584822 一起吹水聊天

    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 的值。// 退出 Java 开发交换君样：756584822 一起吹水聊天
到这里，类的初始化曾经实现，JVM 执行 main 办法的内容。public static void main(String[] args)
{staticFunction();
}
即输入：「书的静态方法」。

从下面几个例子能够看出，剖析一个类的执行程序大略能够依照如下步骤：

确定类变量的初始值。在类加载的筹备阶段，JVM 会为类变量初始化零值，这时候类变量会有一个初始的零值。如果是被 final 润饰的类变量，则间接会被初始成用户想要的值。

初始化入口办法。当进入类加载的初始化阶段后，JVM 会寻找整个 main 办法入口，从而初始化 main 办法所在的整个类。当须要对一个类进行初始化时，会首先初始化类结构器（），之后初始化对象结构器（）。
初始化类结构器。JVM 会按程序收集类变量的赋值语句、动态代码块，最终组成类结构器由 JVM 执行。
初始化对象结构器。JVM 会依照收集成员变量的赋值语句、一般代码块，最初收集构造方法，将它们组成对象结构器，最终由 JVM 执行。
如果在初始化 main 办法所在类的时候遇到了其余类的初始化，那么就先加载对应的类，加载实现之后返回。如此重复循环，最终返回 main 办法所在类。

看完了下面的解析之后，再去看看结尾那道题是不是感觉简略多了呢。很多货色就是这样，把握了肯定的办法和常识之后，本来艰难的货色也变得简略许多了。

关于jvm调优:面试之加分项JVM-类加载机制

加载

验证

筹备（重点）

解析

应用

卸载

实战剖析

方法论

总结