深入理解Java虚拟机笔记——虚拟机类加载机制

目录

• 概述
  • 动态加载和动态连接
• 类加载的时机
  • 类的生命周期
  • 被动引用
    • 例子一（调用子类继承父类的字段）
    • 例子二（数组）
    • 例子三（静态常量）
• 类加载的过程
  • 加载
  • 验证
  • 准备
  • 解析
    • 符号引用
    • 直接引用
  • 初始化
• 类加载器
  • 类与类加载器
  • 双亲委派模型
    • 启动类加载器（Bootstrap ClassLoader）
    • 扩展类加载器（Extension ClassLoader）
    • 应用程序类加载器（Application ClassLoader）
    • 工作过程
    • 优点
    • 实现

概述

虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这就是虚拟机的类加载机制。

动态加载和动态连接

在Java语言里面，类型的加载、连接和初始化过程都是在程序运行期间完成的。

类加载的时机

类的生命周期

类从被加载到虚拟机内存中开始，到卸载出内存位置，它的整个生命周期包括： 加载(Loading)、验证(Verification)、准备(Preparing)、解析(Resolution)、初始化(Initialization)、使用(Using)和卸载(Unloading) 7个阶段。其中验证、准备、解析3个部分统称为连接(Linking)。

被动引用

例子一（调用子类继承父类的字段）

看下面这段代码：

class SuperClass {
    static {
        System.out.println("super class !!!");
    }
    public static int value = 100;
}

class SubClass extends SuperClass {
    static {
        System.out.println("sub class !!!");
    }
}

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

输出：

super class !!!
100

对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化。

例子二（数组）

public class Main {
    public static void main(String[] args) {
        SuperClass[] sca = new SuperClass[10];
    }
}

不会输出 super class !!!。

没有触发类SuperClass的初始化阶段,而是触发了[LSuperClass的类的初始化阶段。

例子三（静态常量）

class ConstClass {
    static {
        System.out.println("ConstClass");
    }
    public static final String S = "hello";
}

public class Main {

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

输出

hello

虽然在Java源码中引用了ConstClass类中的常量S，但其实在编译阶段通过常量传播优化，已经将此常量的值存储到Main类的常量池中，以后Main对常量ConstClass.S的引用实际都被转化为Main类对自身常量池的引用。即实际上Main的Class文件并没有ConstClass类的符号引用入口。

类加载的过程

加载

在加载阶段，虚拟机完成以下三件事情：

1. 通过一个类的全限定名来获取定义此类的二进制字节流。
2. 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
3. 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

加载阶段可以用系统提供的引导类加载器完成，也可以由用户自定义的类加载器去完成。

数组类本身不通过类加载器创建，由Java虚拟机直接创建。 但是数组类的元素类型（去掉所有维度后的类型）最终是要靠类加载器去创建。

验证

验证阶段大致会完成下面四个阶段的验证工作：文件格式验证、元数据验证、字节码验证、符号引用验证。

1. 文件格式验证：主要目的是保证输入的字节流能正确地解析并存储于方法区之内，格式上符合描述一个Java类型信息的要求。这个阶段的验证是基于二进制字节流进行的，只有通过这个阶段验证，字节流才会进入内存的方法区进行存储。
2. 元数据验证：主要目的是对类的元数据信息进行语义校验，保证不存在不符合Java语言规范的元数据信息。
3. 字节码验证：主要目的是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。保证被校验类的方法在运行时不会做出危害虚拟机安全的事件。JDK1.6后给方法体Code属性的属性表添加StackMapTable属性（栈图）进行优化。
4. 符号引用验证：目的是确保解析动作能正常执行。

准备

准备阶段是正式为类变量（被static修饰的变量，不包括实例变量）分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。

public static int value = 233;

变量value在准备阶段过后的初始值为0而不是233，这时候尚未开始执行任何方法，把value赋值是程序被编译后，所以赋值的动作将在初始化阶段才会执行。

如果变成

public static final int value = 233;

那么准备阶段变量value就会被初始化为类字段的字段属性表中ConstantValue属性所指定的值233。

解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。

符号引用

符号引用以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。与虚拟机实现的内存布局无关，引用的目标不一定已经加载到内存中。符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。

直接引用

直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。与虚拟机实现的内存布局相关，如果有直接引用，那引用目标必定在内存中存在。

初始化

类初始化是类加载过程的最后一步，也是真正开始执行类中定义的Java程序代码（或者说是字节码） 的一步。

初始化阶段是执行类构造器<clinit>()方法的过程。

• <clinit>()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，收集顺序是由语句在源文件中出现的顺序决定的。静态语句块中只能访问到定义在静态语句块之前的变量，定义在之后的变量可以赋值，不能访问。
• 虚拟机会保证子类的<clinit>()方法执行前，父类的<clinit>()方法已经执行完毕。虚拟机中第一个执行<clinit>()的类一定是Object类。
• 不是每个类都有<clinit>()方法。
• 执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用，父接口才会初始化。接口实现类初始化时也不会执行接口的<clinit>()方法。
• 虚拟机保证一个类的<clinit>()方法在多线程环境中被正确加锁、同步。

类加载器

实现 “通过一个类的全限定名来获取描述此类的二进制字节流” 的代码模块称为类加载器。

类与类加载器

对于任意一个类，都需要由加载它的类加载器和这个类本身一同确立其在Java虚拟机中的唯一性，每个类加载器，都拥有一个独立的类名称空间。（类加载器不同，两个类就必定不相等）

双亲委派模型

从JVM角度，只存在两种不同的类加载器：第一种是启动类加载器，这个类加载器使用C++实现，是虚拟机的一部分。第二种是所有其他的类加载器，由Java实现，独立于虚拟机外部，并都继承自抽象类java.lang.ClassLoader。

启动类加载器（Bootstrap ClassLoader）

负责将存放在<JAVA_HOME>\lib目录中的，或者被-Xbootclasspath参数所指定的路径中的，并且是虚拟机识别的类库加载到虚拟机内存中。

扩展类加载器（Extension ClassLoader）

由sun.misc.Launcher$ExtClassLoader实现，负责加载<JAVA_HOME>\lib\ext目录中的，或者被java.ext.dirs系统变量所指定的路径中的所有类库。

应用程序类加载器（Application ClassLoader）

也叫作系统类加载器。由sun.misc.Launcher$AppClassLoader实现，负责加载用户类路径（ClassPath）上锁指定的类库。一般情况下这是程序中默认的类加载器。

---

该图展示的类加载器之间的层次关系，称为类加载器的双亲委派模型。

工作过程

一个类加载器收到类加载请求，它首先把请求委派给父类加载器去完成，每一个层次的类加载器都是如此，因此所有加载请求最终会传送到顶层的启动类加载器中。只有当父加载器反馈自己无法完成这个加载请求（它的搜索范围没有找到所需的类）时，子加载器才会尝试自己去加载。

优点

Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如java.lang.object，无论哪个类加载器加载这个类，最终委派给启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。如果没有双亲委派模型，由各个类加载器自行加载，那系统会出现多个不同的Object类。

实现

代码集中在java.lang.ClassLoader的loadClass()方法中。

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        Class<?> c = findLoadedClass(name);
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                c = findClass(name); // 指定自己的类加载实现

                // this is the defining class loader; record the stats
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        if (resolve) {
            resolveClass(c); // 类连接操作
        }
        return c;
    }
}

逻辑：先检查是否已经被加载过，若没有加载则调用父加载器的loadClass()方法，若父加载器为空则默认使用启动类加载器作为父加载器。如果父加载器加载失败，抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。