Java类加载机制

一、什么是类加载机制

先来看Java程序运行图：

我们平时写的Java代码都是保存为.java后缀的，当想要执行java代码时，首先需要将.java文件编译成以.class为后缀的字节码文件，然后类加载器将.class字节文件加载到JVM当中，最后在JVM中运行我们编写的代码。
Java的类加载机制所做的工作就是将经编译器编译后的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构。

二、触发类加载的时机

通过new关键字创建对象；
访问类的静态变量；
访问类的静态方法；
使用java.lang.reflect包的方法对某个类进行反射；
加载子类时若父类未进行初始化，会导致父类的加载；
包含main方法的启动类。

三、类加载机制的过程

从类的加载到卸载共经历7个阶段，加载则只有前5个阶段，分别如下：

第一阶段：加载

下面是对于加载过程最为官方的描述。

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

用一句话来说就是：把代码数据加载到内存中。

第二阶段：验证

当 JVM 加载完 Class 字节码文件并在方法区创建对应的 Class 对象之后，JVM 便会启动对该字节码流的校验，只有符合 JVM 字节码规范的文件才能被 JVM 正确执行。这个校验过程大致可以分为下面几个类型：

JVM规范校验。JVM 会对字节流进行文件格式校验，判断其是否符合 JVM 规范，是否能被当前版本的虚拟机处理。例如：文件是否是以 0x CAFEBABE 开头，主次版本号是否在当前虚拟机处理范围之内等。
代码逻辑校验。JVM 会对代码组成的数据流和控制流进行校验，确保 JVM 运行该字节码文件后不会出现致命错误。例如一个方法要求传入 int 类型的参数，但是使用它的时候却传入了一个 String 类型的参数。一个方法要求返回 String 类型的结果，但是最后却没有返回结果。

用一句话来说就是：验证class文件呢是否符合JVM规范。

第三阶段：准备

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

内存分配对象：Java中的变量分为类变量和类成员变量两种，类变量指的是被static修饰的变量，除此之外的其他变量都是类成员变量，在准备阶段，JVM只会为类变量分配内存，而不会为类成员变量分配内存，类成员变量的内存分配需要等到初始化阶段才开始。

例如下面的代码，在准备阶段的时候，只会为age分配内存，而不会为number分配内存。

private static int age = 10;
private int number = 8;

初始化的类型：在准备阶段，JVM会为类变量分配内存，并为其初始化。但是这里的初始化指的是为变量赋予Java语言中该数据类型的零值，而不是用户代码里初始化的值。

例如下面的代码在准备阶段之后，age的值将是0，而不是10。

private static int age = 10;

但如果一个变量是常量（被static final修饰）的话，那么在准备阶段，属性便会被赋予用户希望的值。例如下面的代码在准备阶段之后，age的值将是10，而不是0。

private static final int age = 10;

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

第四阶段：解析

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

符号引用：即用一组符号代表引用的目标。如在学校中同学给你取的外号。
直接引用：目标的指针、相对偏移量或者句柄。即在学校中唯一指向你本人的学号。

第五阶段：初始化

类加载过程的最后一步，在该阶段中JVM为类中的变量赋值，如在准备阶段中只赋了默认值的变量，在这里会赋上真实值，同时也会为实例变量赋值。
例如下面的代码在初始化阶段之后，age的值将是10，而不再是0。

private static int age = 10;

第六阶段：使用

当JVM完成初始化阶段之后，即类加载过程已完成，JVM便开始从入口方法开始执行用户的程序代码。

第七阶段：卸载

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

看完了类加载机制之后，下面我们来看几个小例子，通过这几个例子来熟悉一下类加载的这个过程。

public class Book {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
    
    Book() {
        System.out.println("书的构造方法");
        System.out.println("price = " + price + ", amount = " + amount);
    }
    
    {
        System.out.println("书的普通代码块");
    }
    
    static {
        System.out.println("书的静态代码块");
    }
    
    private int price = 110;
    private static int amount = 112;
}

思考一下上面这段代码会输出什么结果呢？

好，公布答案啦：

书的静态代码块
Hello World

下面我们来简单分析一下，根据第二节中的触发类加载的时机中的第6条，我们会进行包含main()方法的启动类的初始化，那么类的初始化顺序到底是怎么样的呢？

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

类初始化方法：编译器会按照其出现顺序，收集类变量的赋值语句、静态代码块，最终组成类初始化方法。类初始化方法一般在类初始化的时候执行。

对于上面的例子，其类初始化方法为下面这段代码：

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

对象初始化方法：编译器会按照其出现顺序，收集成员变量的赋值语句、普通代码块，最后收集构造函数的代码，最终组成对象初始化方法。对象初始化方法一般在实例化类对象的时候执行。

对于上面的例子，其对象初始化方法为下面这段代码：

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

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

但细心的朋友一定会发现，其实上面的这个例子其实没有执行对象初始化方法。

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

通过了上面的理论和简单例子，我们下面进入更加复杂的实战分析吧！

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

//Father类
public class Father extends Grandpa {
    static {
        System.out.println("爸爸在静态代码块");
    }
    public static int factor = 25;
 
    public Father() {
        System.out.println("我是爸爸~");
    }
}

//Son类
public 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

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

这是因为对于静态字段，只有直接定义了这个字段的类才会被初始化，而上面例子中的Son类并没有factor这个字段，所以不会初始化Son类。因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

大家也可以自己尝试一下，当在Son类中定义了factor这个字段后，输出的结果就会有「儿子在静态代码块」了。

对于上面的这个例子，我们可以从入口开始分析一路分析下去：

首先程序到main方法这里，使用标准化输出Son类中的factor类成员变量，但是Son类中并没有定义这个类成员变量。于是往父类去找，我们在Father类中找到了对应的类成员变量，于是触发了Father的初始化。
但根据我们上面说到的类加载的触发时机的第5种（加载子类时若父类未进行初始化，会导致父类的加载）。我们需要先初始化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) {
        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方法是程序的入口，根据我们上面说到的触发类加载的时机的第6条，所以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中的类加载器

Bootstrap ClassLoader(启动类加载器)：是最顶层的类加载器，没有父类。它是用C++编写的，主要用来加载JDK安装目录下jre/lib/中用于支撑Java系统运行的核心类库，例如：java.lang包下的类。
ExtClassLoader(扩展类加载器)：主要用于加载JAVA_HOME下的jre/lib/ext子目录下的类库，它的父类是启动类加载器。扩展类加载器是由纯Java代码实现的，它的完整类名是sun.misc.Launcher$ExtClassLoader。
AppClassLoader(系统类加载器)：主要负责classpath下的类资源加载，我们开发过程中所依赖的第三方jar包默认就是系统类加载器加载的。系统类加载器的父类是扩展类加载器，其类全名是sun.misc.Launcher$AppClassLoader。
CustomClassLoader(自定义类加载器)：虽然Java中已经提供了3个类加载器，但是有一些弊端，比如只能加载指定目录下的jar包或者class文件，如果我们想加载其它位置的 jar或者class文件时，比如网络上的某 class通过动态加载到内存来使用，这样的场景默认的类加载器就不能给我们提供帮助了，所以就要自己定义 ClassLoader。自定义类的加载器继承 ClassLoader 然后重写父类的findClass方法，之所以只重写这个方法是因为JDK已经在loadClass中帮我们使用了ClassLoader搜索类的算法，当在loadClass方法中找不到类时，loadClass方法就会调用findClass方法来搜索类，所以只要重写它就好了。

五、双亲委派模型

Java的类加载采用了双亲委派模型，当一个类加载器接到一个加载任务的时候，会先交于它的父加载器去执行，直到最顶层的根类加载器，当根类加载器无法完成任务（即无法找到负责的目录下的该类）时，再一层层往下传到子类去执行。

使用双亲委派模型的好处是：一方面可以避免重复加载，当父类已经加载了一个类的时候，就没必要在子类加载器ClassLoader中再去加载一次了；另一方面是安全性的问题，可以保证同一个类被特定的加载器加载，防止用户随意定义加载器来加载核心的api。

六、思考

能否自己定义一个类 java.lang.String ，然后自己拿来在应用程序中使用?

答：通常不可以的，依照类的双亲委派模型,总是会去父类加载器中去找Java.lang.String，看父类加载器能否加载，这样能够保证父类加载器优先加载，如果父类加载完了子类就不需要再次加载了，而 rt.jar 这个核心包是BootStrap这个顶级的加载器加载的，所以自己写的根本就没用被加载的机会。

如果非要实现使用自己定义的java.lang.String，我们可以定义一个类加载器达到这个目的，当然这个流程肯定要避免双亲委派机制，所以这个类加载器也是特殊的，由于系统自带的那三个类加载器都是特定目录下的类，所以我们需要把自己的类加载器放在一个特殊的目录里不让那三个类加载器去加载，最终由我们自己定义的类加载器加载。