深入JVM内核6 类装载过程

深入JVM内核目录

1 class装载验证流程

1.1 加载

装载类的第一个阶段
取得类的二进制流
转为方法区数据结构
在Java堆中生成对应的java.lang.Class对象

1.2 链接

(1) 验证

目的：保证Class流的格式是正确的

文件格式的验证
是否以0xCAFEBABE开头
版本号是否合理
元数据验证
是否有父类
继承了final类？
非抽象类实现了所有的抽象方法
字节码验证 (很复杂)
运行检查
栈数据类型和操作码数据参数吻合
跳转指令指定到合理的位置
符号引用验证
常量池中描述类是否存在
访问的方法或字段是否存在且有足够的权限

(2) 准备

分配内存，并为类设置初始值（方法区中）

public static int v=1;
在准备阶段中，v会被设置为0
在初始化的中才会被设置为1
对于static final类型，在准备阶段就会被赋上正确的值
public static final int v=1;

(3) 解析

符号引用替换为直接引用

字符串引用对象不一定被加载
指针或者地址偏移量引用对象一定在内存

1.3 初始化

执行类构造器
static变量赋值语句
static{}语句
子类的调用前保证父类的被调用
是线程安全的

那么Java.lang.NoSuchFieldError错误可能在什么阶段抛出呢？

很显然是在链接的验证阶段的符号引用验证时会抛出这个异常，或者NoSuchMethodError等异常。

2 什么是类加载器ClassLoader

ClassLoader是一个抽象类
ClassLoader的实例将读入Java字节码将类装载到JVM中
ClassLoader可以定制，满足不同的字节码流获取方式
ClassLoader负责类加载过程中的加载阶段

2.1 ClassLoader的重要方法

public Class loadClass(String name) throws ClassNotFoundException

载入并返回一个Class

protected final Class defineClass(byte[] b, int off, int len)

定义一个类，不公开调用

protected Class findClass(String name) throws ClassNotFoundException

loadClass回调该方法，自定义ClassLoader的推荐做法

protected final Class findLoadedClass(String name)

2.2 ClassLoader分类

BootStrap ClassLoader （启动ClassLoader）
Extension ClassLoader （扩展ClassLoader）
App ClassLoader （应用ClassLoader/系统ClassLoader）
Custom ClassLoader(自定义ClassLoader)
每个ClassLoader都有一个Parent作为父亲

3 JDK中ClassLoader默认设计模式

路径：
Bootstrap ClassLoader rt.jar /-Xbootclasspath
Extension ClassLoader %JAVA_HOME%/lib/ext/*.jar
App ClassLoader Classpath完全自定义路径
Custom ClassLoader 完全自定义路径

底向上检查类是否被加载，一般情况下，首先先从AppClassLoader中调用findLoadedClass查看是否已经加载，如果没有加载，则会交给父类，ExtensionClassLoader去查看是否加载，还没加载，则再调用其父类，BootstrapClassLoader查看是否已经加载，如果仍然没有，自顶向下尝试加载类，那么从 BootstrapClassLoader到 AppClassLoader依次尝试加载。
从代码上可以很容易看出来，首先先自己查看这个类是否被调用，如果没有找到，则调用父亲的loadClass，直到BootstrapClassLoader（没有父亲）。

我们把这个加载的过程叫做双亲模式。

双亲委托机制的作用是防止系统jar包被本地替换

3.1 双亲模式的问题

这种模式下会有一个问题：
顶层ClassLoader，无法加载底层ClassLoader的类

Java框架(rt.jar)如何加载应用的类？

比如：javax.xml.parsers包中定义了xml解析的类接口
Service Provider Interface SPI 位于rt.jar
即接口在启动ClassLoader中。
而SPI的实现类，在AppLoader。

这样就无法用BootstrapClassLoader去加载SPI的实现类。

3.2 解决

JDK中提供了一个方法：

Thread. setContextClassLoader()

上下文加载器
是一个角色
用以解决顶层ClassLoader无法访问底层ClassLoader的类的问题
基本思想是，在顶层ClassLoader中，传入底层ClassLoader的实例
上下文ClassLoader可以突破双亲模式的局限性

static private Class getProviderClass(String className, ClassLoader cl,
        boolean doFallback, boolean useBSClsLoader) throws ClassNotFoundException
{
    try {
        if (cl == null) {
            if (useBSClsLoader) {
                return Class.forName(className, true, FactoryFinder.class.getClassLoader());
            } else {
                cl = ss.getContextClassLoader();
                if (cl == null) {
                    throw new ClassNotFoundException();
                }
                else {
                    return cl.loadClass(className); //使用上下文ClassLoader
                }
            }
        }
        else {
            return cl.loadClass(className);
        }
    }
    catch (ClassNotFoundException e1) {
        if (doFallback) {
            // Use current class loader - should always be bootstrap CL
            return Class.forName(className, true, FactoryFinder.class.getClassLoader());
        }
…..

代码来自于
javax.xml.parsers.FactoryFinder
展示如何在启动类加载器加载AppLoader的类

上下文ClassLoader可以突破双亲模式的局限性

3.3 双亲模式的破坏

双亲模式是默认的模式，但不是必须这么做
Tomcat的WebappClassLoader 就会先加载自己的Class，找不到再委托parent
OSGi的ClassLoader形成网状结构，根据需要自由加载Class

破坏双亲模式例子- 先从底层ClassLoader加载

OrderClassLoader的部分实现

protected synchronized Class loadClass(String name, boolean resolve) throws ClassNotFoundException {
    // First, check if the class has already been loaded
    Class re=findClass(name);
    if(re==null){
        System.out.println(“无法载入类:”+name+“ 需要请求父加载器");
        return super.loadClass(name,resolve);
    }
    return re;
}

protected Class findClass(String className) throws ClassNotFoundException {
Class clazz = this.findLoadedClass(className);
if (null == clazz) {
    try {
        String classFile = getClassFile(className);
        FileInputStream fis = new FileInputStream(classFile);
        FileChannel fileC = fis.getChannel();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        WritableByteChannel outC = Channels.newChannel(baos);
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
         省略部分代码
        fis.close();
        byte[] bytes = baos.toByteArray();

        clazz = defineClass(className, bytes, 0, bytes.length);
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }
}
return clazz;
}

特别感谢

深入JVM内核—原理、诊断与优化