Java基础篇—Java类加载机制

Java 类加载机制

Java类加载过程

基于 JDK8，面试常见题型，能够先试试下面的牛刀小试面试题，而后再通读全文，效果更佳~

类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括

• 加载 Loading
• 连接 Linking
  • 验证 Verification
  • 准备 Preparation
  • 解析 Resolution
• 初始化 Initialization
• 使用 Using
• 卸载 Unloading

加载、验证、准备、初始化和 卸载 这5个阶段的顺序是肯定的，类的加载过程必须按照这种顺序循序渐进地开始，而后一般互相交叉地混合式进行，而解析阶段则不必定：它在某些状况下能够在初始化阶段以后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。

加载

加载的过程当中主要作了3件事：

• 经过一个类的全限定名来获取定义此类的二进制流
• 将二进制流所表明的存储结构转化为方法区的运行时数据结构。
• 在内存中生成一个表明这个类的 java.lang.Class 对象，做为方法区的各类数据访问入口。

对于一个类或者接口

• 若是该类不是数组类，则使用类加载器加载二进制表示。
• 若是该类是数组类，则由Java虚拟机建立，由于数组类不具备外部二进制表示形式。

类加载器种类

有两种类型的类加载器：

• 由 JVM 提供的 bootstrap 类加载器：用于加载 系统变量 sun.boot.class.path 所表明的路径下的 class 文件，顶层父类

• 用户定义的类加载器（java 类库中定义的也包括在内）

  • ExtClassLoader：sun.misc.Launcher 类中定义，用于加载 系统变量 java.class.path 所表明的路径下的 class 文件；父类加载器为 bootstrap
  • AppClassLoader：sun.misc.Launcher 类中定义，用于加载 系统变量 java.ext.dirs 所表明的 路径下 class 文件；父类加载器为 ExtClassLoader
  • 其余，固然你也能够定义其余类型的类加载器

类加载器加载原理

ClassLoader 使用 双亲委派模型 来加载类，每一个 ClassLoader 实例都持有父类加载器的引用，虚拟机内置的 bootstrap 类加载器为顶层父类加载器，没有父类加载器，但能够做为其它 ClassLoader 实例的父类加载器。当 ClassLoader 实例须要加载某个类时，它会先委派其父类加载器去加载。这个过程是由上至下依次检查的，首先由最顶层的类加载器Bootstrap ClassLoader试图加载，若是没加载到，则把任务转交给Extension ClassLoader试图加载，若是也没加载到，则转交给App ClassLoader 进行加载，若是它也没有加载获得的话，则返回给委托的发起者，由它到指定的文件系统或网络等URL中加载该类。若是它们都没有加载到这个类时，则抛出ClassNotFoundException异常。不然将这个找到的类生成一个类的定义，并将它加载到内存当中，最后返回这个类在内存中的Class实例对象。

双亲委派机制的优势是能够避免类的重复加载，当父类加载了子类就不必再加载。另外可以保证虚拟机的安全，防止内部实现类被自定义的类替换。

那么JVM在搜索类的时候，如何判断两个 class 是否相同呢？答案是不只全类名要相同 ，并且还要由同一个类加载器实例加载。

验证

主要确保类或接口的二进制表示在结构上是正确的。

准备

准备工做包括为类或接口建立静态字段，并将这些字段初始化为其默认值，这里 不须要执行任何 java 代码。

例如，对于类或接口中的以下静态字段

private static int num = 666;
复制代码

在准备阶段会为 num 设置默认值 0；在后面的初始化阶段才会给 num 赋值 666；

特殊状况：对于同时被 static 和 final 修饰的 字段，准备阶段就会赋值。

解析

解析是将运行常量池中的符号引用 动态肯定为具体值的过程。解析动做主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

初始化

初始化阶段是初始化类变量和其余资源，或者说是执行类构造器<clinit>()方法的过程.

<clinit>()方法是由编译器自动收集类中的全部==类变量==(static 修饰的变量)的赋值动做和静态语句块static{}中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块只能访问到定义在静态语句块以前的变量，定义在它以后的变量，在前面的静态语句块能够赋值，可是不能访问。

例如：非法向前引用变量示例

static {
    i = 2;
    System.out.println(i); //illegal forward reference
}
static int i = 4;
复制代码

<clinit>()方法与类的构造函数(或者说实例构造器<init>()方法)不一样，它不须要显示地调用父类构造器，虚拟机会保证在子类的<clinit>()方法执行以前，父类的<clinit>()方法已经执行完毕。所以在虚拟机中第一个被执行的<clinit>()方法的类确定是 java.lang.Object。接口与类不一样的是，执行接口的<clinit>()方法不须要先执行父接口的<clinit>()方法，只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口的实现类在初始化时也同样不会执行接口的<clinit>()方法。

<clinit>()方法是类构造器，在类初始化的时候执行，用于 类中的静态代码块 和 静态字段 初始化的方法，只会执行一次。

<init>()方法是 类实例的构造器，在对象的初始化阶段执行，用于非静态字段，非静态代码块，构造函数的初始化，能够执行屡次。

类或者接口只能因为如下缘由初始化：

1. 使用 new 建立新对象，若是引用的类还没有被初始化，则初始化该类；或者从类中获取 静态字段、设置静态字段、执行类中的静态方法时，若是尚未被初始化，则 声明该字段或者方法的类或者接口被初始化
2. 第一次调用 java.lang.invoke.method handle实例，调用了静态方法，或者 new 的方法的句柄。
3. 使用 java.lang.reflect 包的方法对类进行反射调用的时候，若是类没有进行过初始化，则须要先触发其初始化
4. 当初始化一个类的时候，若是发现其父类尚未进行过初始化，则须要先触发其父类的初始化
5. 当初始化一个类，而该类直接或者间接 实现了 一个 不含有抽象方法，和静态方法的接口，则须要初始化该接口。
6. 当虚拟机启动时，用户须要指定一个要执行的主类（包含main()方法的那个类），虚拟机会先初始化这个主类。

牛刀小试1

执行以下代码，输出如何：

public class SSClass {
    static
    {
        System.out.println("SSClass");
    }
}    
public class SuperClass extends SSClass {
    static
    {
        System.out.println("SuperClass init!");
    }

    public static int value = 123;

    public SuperClass() {
        System.out.println("init SuperClass");
    }
}
public class SubClass extends SuperClass {
    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);
    }
}

复制代码

输出：

SSClass
SuperClass init!
123
复制代码

解析：

上面提到了这样一句话：

从类中获取 静态字段、设置静态字段、执行类中的静态方法时，若是尚未被初始化，则 声明该字段或者方法的类或者接口被初始化

因此 SubClass 类并不会被初始化，因此也就不会执行其 静态代码块；

牛刀小试2

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;
}

复制代码

问题：执行上面的程序，输出结果是什么？

答案：执行以上代码的输出结果：

2
3
a=110,b=0
1
4
复制代码

解析：

• 执行 main 方法，会致使主类 StaticTest 初始化，因为还未加载，先执行加载，主要分析 准备阶段 和 初始化阶段 的 赋值操做。

• 准备阶段 : 为静态字段赋初始值，st 设为 null ，b 设为 0；

• 初始化阶段：执行 Java 代码的类构造器 <clinit>()方法，分别按顺序执行以下代码：

  • static StaticTest st = new StaticTest()；new 会 致使 StaticTest 类执行类初始化，执行 <init>()方法，对象的初始化是先初始化成员变量 和 代码块，再载执行构造方法；
    • int a = 110;
    • System.out.println("2");
    • System.out.println("3");
    • System.out.println("a=" + a + ",b=" + b);
  • static 静态代码块，System.out.println("1");
  • static int b = 112;

• 调用 staticFunction() 方法，System.out.println("4");

稍微修改一下代码，去除 如下代码，或许就变得正常多了，

static StaticTest st = new StaticTest();
复制代码

输出：

1
4
复制代码

减小了 类实例化的步骤。

父类和子类的初始化顺序能够简单用如下几句话归纳：

• 父类的静态变量赋值
• 自身的静态变量赋值
• 父类成员变量赋值和父类块赋值
• 父类构造函数赋值
• 自身成员变量赋值和自身块赋值
• 自身构造函数赋值

参考：

深刻理解Java虚拟机

oracle 官方文档

欢迎关注编程那点事儿，随时随地，想学就学，扫码关注吧~