JVM类加载机制详解

本文来详细说下JVM类加载机制

---

概述

本文将由浅及深，介绍Java类加载的过程和原理，进一步对类加载器的进行源码分析，深入理解类加载器机制。

---

类加载器是什么

类加载器简言之，就是用于把.class文件中的字节码信息转化为具体的java.lang.Class对象的过程的工具。

具体过程：

1. 在实际类加载过程中，JVM会将所有的.class字节码文件中的二进制数据读入内存中，导入运行时数据区的方法区中。
2. 当一个类首次被主动加载或被动加载时，类加载器会对此类执行类加载的流程 – 加载、连接（验证、准备、解析）、初始化。
3. 如果类加载成功，堆内存中会产生一个新的Class对象，Class对象封装了类在方法区内的数据结构。

Class对象的创建过程描述：

---

类加载的过程

类加载的过程分为三个步骤(五个阶段) ：加载 -> 连接（验证、准备、解析）-> 初始化。

加载、验证、准备和初始化这四个阶段发生的顺序是确定的，而解析阶段可以在初始化阶段之后发生，也称为动态绑定或晚期绑定。

类加载的过程描述：

---

加载

加载：查找并加载类的二进制数据的过程。

加载的过程描述：

• 通过类的全限定名定位.class文件，并获取其二进制字节流。
• 把字节流所代表的静态存储结构转换为方法区的运行时数据结构。
• 在Java堆中生成一个此类的java.lang.Class对象，作为方法区中这些数据的访问入口。

---

连接

连接：包括验证、准备、解析三步。

a). 验证

验证：确保被加载的类的正确性。验证是连接阶段的第一步，用于确保Class字节流中的信息是否符合虚拟机的要求。

具体验证形式：

• 文件格式验证：验证字节流是否符合Class文件格式的规范；例如：是否以0xCAFEBABE开头、主次版本号是否在当前虚拟机的处理范围之内、常量池中的常量是否有不被支持的类型。
• 元数据验证：对字节码描述的信息进行语义分析（注意：对比javac编译阶段的语义分析），以保证其描述的信息符合Java语言规范的要求；例如：这个类是否有父类，除了java.lang.Object之外。
• 字节码验证：通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。
  符号引用验证：确保解析动作能正确执行

b). 准备

准备：为类的静态变量分配内存，并将其初始化为默认值。准备过程通常分配一个结构用来存储类信息，这个结构中包含了类中定义的成员变量，方法和接口信息等。

具体行为：

• 这时候进行内存分配的仅包括类变量(static)，而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。
• 这里所设置的初始值通常情况下是数据类型默认的零值（如0、0L、null、false等），而不是被在Java代码中被显式赋值。

c). 解析

解析：把类中对常量池内的符号引用转换为直接引用。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符等7类符号引用进行。

---

初始化

初始化：对类静态变量赋予正确的初始值 (注意和连接时的解析过程区分开)。

初始化的目标

• 实现对声明类静态变量时指定的初始值的初始化；
• 实现对使用静态代码块设置的初始值的初始化

初始化的步骤

• 如果此类没被加载、连接，则先加载、连接此类；
• 如果此类的直接父类还未被初始化，则先初始化其直接父类；
• 如果类中有初始化语句，则按照顺序依次执行初始化语句。

初始化的时机

• 创建类的实例(new关键字)；
• java.lang.reflect包中的方法(如：Class.forName(“xxx”))；
• 对类的静态变量进行访问或赋值；
• 访问调用类的静态方法；
• 初始化一个类的子类，父类本身也会被初始化；
• 作为程序的启动入口，包含main方法(如：SpringBoot入口类)。

---

类的主动引用和被动引用

主动引用

主动引用：在类加载阶段，只执行加载、连接操作，不执行初始化操作。

主动引用的几种形式

• 创建类的实例(new关键字)；
• java.lang.reflect包中的方法(如：Class.forName(“xxx”))；
• 对类的静态变量进行访问或赋值；
• 访问调用类的静态方法；
• 初始化一个类的子类，父类本身也会被初始化；
• 作为程序的启动入口，包含main方法(如：SpringBoot入口类)。

主动引用1 - main方法在初始类中

package cn.wideth.bean;

public class OptimisticReference0 {

    static {
        System.out.println(OptimisticReference0.class.getSimpleName() + " is referred!");
    }

    public static void main(String[] args) {
        System.out.println();
    }
}

程序结果

---

主动引用2 – 创建子类会触发父类的初始化

package cn.wideth.bean;

public class OptimisticReference1 {
    
    public static class Parent {
        static {
            System.out.println(Parent.class.getSimpleName() + " is referred!");
        }
    }

    public static class Child extends Parent {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        new Child();
    }
}

程序结果

---

主动引用3 – 访问一个类静态变量

package cn.wideth.bean;

public class OptimisticReference2 {
    
    public static class Child {
        protected static String name;
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
            name = "Child";
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

程序结果

---

主动引用4 – 对类的静态变量进行赋值

package cn.wideth.bean;

public class OptimisticReference3 {

    public static class Child {
        protected static String name;
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        Child.name = "Child";
    }
}

程序结果

---

主动引用5 – 使用java.lang.reflect包提供的反射机制

package cn.wideth.bean;

public class OptimisticReference4 {

    public static void main(String[] args) throws ClassNotFoundException {
        Class.forName("cn.wideth.bean.OptimisticReference0");
    }
}

程序结果

---

被动引用

被动引用： 在类加载阶段，会执行加载、连接和初始化操作。

被动引用的几种形式：

• 通过子类引用父类的的静态字段，不会导致子类初始化；
• 定义类的数组引用而不赋值，不会触发此类的初始化；
• 访问类定义的常量，不会触发此类的初始化。

---

被动引用1 – 子类引用父类的的静态字段，不会导致子类初始化

package cn.wideth.bean;

public class NegativeReference0 {
    
    public static class Parent {
        public static String name = "Parent";
        static {
            System.out.println(Parent.class.getSimpleName() + " is referred!");
        }
    }

    public static class Child extends Parent {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

程序结果

---

被动引用2 – 定义类的数组引用而不赋值，不会触发此类的初始化

package cn.wideth.bean;

public class NegativeReference1 {

    public static class Child {
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        Child[] childs = new Child[10];
    }
}

无输出

---

被动引用3 – 访问类定义的常量，不会触发此类的初始化

package cn.wideth.bean;

public class NegativeReference2 {
    
    public static class Child {
        public static final String name = "Child";
        static {
            System.out.println(Child.class.getSimpleName() + " is referred!");
        }
    }

    public static void main(String[] args) {
        System.out.println(Child.name);
    }
}

程序结果

---

三种类加载器

类加载器：类加载器负责加载程序中的类型（类和接口），并赋予唯一的名字予以标识。

类加载器的组织结构

类加载器的关系

• Bootstrap Classloader 是在Java虚拟机启动后初始化的。
• Bootstrap Classloader 负责加载 ExtClassLoader，并且将 ExtClassLoader的父加载器设置为 Bootstrap Classloader
• Bootstrap Classloader 加载完 ExtClassLoader 后，就会加载 AppClassLoader，并且将 AppClassLoader 的父加载器指定为 ExtClassLoader。

类加载器的作用

Class Loader	实现方式	具体实现类	负责加载的目标
Bootstrap Loader	C++	由C++实现	%JAVA_HOME%/jre/lib/rt.jar以及-Xbootclasspath参数指定的路径以及中的类库
Extension ClassLoader	Java	sun.misc.Launcher$ExtClassLoader	%JAVA_HOME%/jre/lib/ext路径下以及java.ext.dirs系统变量指定的路径中类库
Application ClassLoader	Java	sun.misc.Launcher$AppClassLoader	Classpath以及-classpath、-cp指定目录所指定的位置的类或者是jar文档，它也是Java程序默认的类加载器

类加载器的特点

• 层级结构：Java里的类装载器被组织成了有父子关系的层级结构。Bootstrap类装载器是所有装载器的父亲。
• 代理模式： 基于层级结构，类的代理可以在装载器之间进行代理。当装载器装载一个类时，首先会检查它在父装载器中是否进行了装载。如果上层装载器已经装载了这个类，这个类会被直接使用。反之，类装载器会请求装载这个类
• 可见性限制：一个子装载器可以查找父装载器中的类，但是一个父装载器不能查找子装载器里的类。
• 不允许卸载：类装载器可以装载一个类但是不可以卸载它，不过可以删除当前的类装载器，然后创建一个新的类装载器装载。

类加载器的隔离问题

每个类装载器都有一个自己的命名空间用来保存已装载的类。当一个类装载器装载一个类时，它会通过保存在命名空间里的类全局限定名(Fully Qualified Class Name) 进行搜索来检测这个类是否已经被加载了。

JVM 及 Dalvik 对类唯一的识别是 ClassLoader id + PackageName + ClassName，所以一个运行程序中是有可能存在两个包名和类名完全一致的类的。并且如果这两个类不是由一个 ClassLoader 加载，是无法将一个类的实例强转为另外一个类的，这就是 ClassLoader 隔离性。

为了解决类加载器的隔离问题，JVM引入了双亲委托机制。

---

双亲委托机制

核心思想

核心思想：其一，自底向上检查类是否已加载；其二，自顶向下尝试加载类。

具体加载过程

• 当AppClassLoader加载一个class时，它首先不会自己去尝试加载这个类，而是把类加载请求委派给父类加载器ExtClassLoader去完成。
• 当ExtClassLoader加载一个class时，它首先也不会自己去尝试加载这个类，而是把类加载请求委派给BootStrapClassLoader去完成。
• 如果BootStrapClassLoader加载失败（例如在%JAVA_HOME%/jre/lib里未查找到该class），会使用ExtClassLoader来尝试加载；
• 如果ExtClassLoader也加载失败，则会使用AppClassLoader来加载，如果AppClassLoader也加载失败，则会报出异常ClassNotFoundException。

---

源码分析

ClassLoader.class

loadClass()：通过指定类的全限定名称，由类加载器检测、装载、创建并返回该类的java.lang.Class对象。

ClassLoader通过loadClass()方法实现了双亲委托机制，用于类的动态加载。
loadClass()本身是一个递归向上调用的过程。

自底向上检查类是否已加载

• 先通过findLoadedClass()方法从最底端类加载器开始检查类是否已经加载。
• 如果已经加载，则根据resolve参数决定是否要执行连接过程，并返回Class对象。
• 如果没有加载，则通过parent.loadClass()委托其父类加载器执行相同的检查操作(默认不做连接处理)。
• 直到顶级类加载器，即parent为空时，由findBootstrapClassOrNull()方法尝试到Bootstrap ClassLoader中检查目标类。

自顶向下尝试加载类

• 如果仍然没有找到目标类，则从Bootstrap ClassLoader开始，通过findClass()方法尝试到对应的类目录下去加载目标类。
• 如果加载成功，则根据resolve参数决定是否要执行连接过程，并返回Class对象。
• 如果加载失败，则由其子类加载器尝试加载，直到最底端类加载器也加载失败，最终抛出ClassNotFoundException。

findLoadedClass()

查找当前类加载器的缓存中是否已经加载目标类。findLoadedClass()实际调用了底层的native方法findLoadedClass0()。

findBootstrapClassOrNull()

查找最顶端Bootstrap类加载器的是否已经加载目标类。同样，findBootstrapClassOrNull()实际调用了底层的native方法findBootstrapClass()。

findClass()

ClassLoader是java.lang包下的抽象类，也是所有类加载器(除了Bootstrap)的基类，findClass()是ClassLoader对子类提供的加载目标类的抽象方法。

注意：Bootstrap ClassLoader并不属于JVM的层次，它不遵守ClassLoader的加载规则，Bootstrap classLoader并没有子类。

defineClass()

defineClass()是ClassLoader向子类提供的方法，它可以将.class文件的二进制数据转换为合法的java.lang.Class对象。

---

类的动态加载

类的几种加载方式

• 通过命令行启动时由JVM初始化加载；
• 通过Class.forName()方法动态加载；
• 通过ClassLoader.loadClass()方法动态加载。

Class.forName()和ClassLoader.loadClass()

• Class.forName()：把类的.class文件加载到JVM中，对类进行解释的同时执行类中的static静态代码块；
• ClassLoader.loadClass()：只是把.class文件加载到JVM中，不会执行static代码块中的内容，只有在newInstance才会去执行。

---

对象的初始化

对象的初始化顺序

静态变量/静态代码块 -> 普通代码块 -> 构造函数

1. 父类静态变量和静态代码块（先声明的先执行）；
2. 子类静态变量和静态代码块（先声明的先执行）；
3. 父类普通成员变量和普通代码块（先声明的先执行）；
4. 父类的构造函数；
5. 子类普通成员变量和普通代码块（先声明的先执行）；
6. 子类的构造函数。

对象的初始化示例

Parent.java

package cn.wideth.wechat.classload;

public class Parent {

    protected static String CLASS_NAME;
    protected static String CLASS_LOADER_NAME;
    protected String instanceID;

    // 1.先执行静态变量和静态代码块（只在类加载期间执行一次）
    static {
        CLASS_NAME = Parent.class.getName();
        CLASS_LOADER_NAME = Parent.class.getClassLoader().toString();
        System.out.println("Step a: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
    }

    // 2.然后执行变量和普通代码块（每次创建实例都会执行）
    {
        instanceID = this.toString();
        System.out.println("Step c: Parent instance is created: "+ CLASS_LOADER_NAME +"->"+ instanceID);
     }

    //3.然后执行构造方法
     public Parent() {
        System.out.println("Step d:Parent instance:"+ instanceID +",constructor is invoked");
     }

}

Children.java

package cn.wideth.wechat.classload;

public class Children extends Parent {

    static {
         CLASS_NAME = Children.class.getName();
         CLASS_LOADER_NAME = Children.class.getClassLoader().toString();
         System.out.println("Step b: " + CLASS_NAME + " is loaded by " + CLASS_LOADER_NAME);
    }

    {
        instanceID = this.toString();
        System.out.println("Step e: Children instance is created:"+ CLASS_LOADER_NAME +"-> "+ instanceID);
    }

    public Children(){
        System.out.println("Step f:Children instance:"+ instanceID +",constructor is invoked");
    }

}

Tester.java

package cn.wideth.wechat.classload;

public class AppClassLoaderTester {

    public static void main(String[] args) {

        new Children();
    }
}

测试结果

测试结果表明：JVM在创建对象时，遵守以上对象的初始化顺序。

---

参考书籍

• 周志明，深入理解Java虚拟机：
• JVM高级特性与最佳实践，机械工业出版社

---

本文小结

本文详细介绍了JVM类加载机制相关的知识。