类加载流程，类加载机制及自定义类加载器详解（面试再也不怕了）

3.4、classloader只会对类进行加载，不会进行初始化1、jvm类加载器分类1.1、bootstrap classloader1.2 、extension classloader1.3、 system classloader1.1、jvm主要的类加载机制。

一、引言

当程序使用某个类时，如果该类还未被加载到内存中，则jvm会通过加载、链接、初始化三个步骤对该类进行类加载。

二、类的加载、链接、初始化

1、加载

类加载指的是将类的class文件读入内存，并为之创建一个java.lang.class对象。类的加载过程是由类加载器来完成，类加载器由jvm提供。我们开发人员也可以通过继承classloader来实现自己的类加载器。

1.1、加载的class来源

• 从本地文件系统内加载class文件
• 从jar包加载class文件
• 通过网络加载class文件
• 把一个java源文件动态编译，并执行加载。

2、类的链接

通过类的加载，内存中已经创建了一个class对象。链接负责将二进制数据合并到 jre中。链接需要通过验证、准备、解析三个阶段。

2.1、验证

验证阶段用于检查被加载的类是否有正确的内部结构，并和其他类协调一致。即是否满足java虚拟机的约束。

2.2、准备

类准备阶段负责为类的类变量分配内存，并设置默认初始值。

2.3、解析

我们知道，引用其实对应于内存地址。思考这样一个问题，在编写代码时，使用引用，方法时，类知道这些引用方法的内存地址吗？显然是不知道的，因为类还未被加载到虚拟机中，你无法获得这些地址。举例来说，对于一个方法的调用，编译器会生成一个包含目标方法所在的类、目标方法名、接收参数类型以及返回值类型的符号引用，来指代要调用的方法。

解析阶段的目的，就是将这些符号引用解析为实际引用。如果符号引用指向一个未被加载的类，或者未被加载类的字段或方法，那么解析将触发这个类的加载（但未必会触发解析与初始化）。

3、类的初始化

类的初始化阶段，虚拟机主要对类变量进行初始化。虚拟机调用< clinit>方法，进行类变量的初始化。

java类中对类变量进行初始化的两种方式：

1. 在定义时初始化
2. 在静态初始化块内初始化

3.1、< clinit>方法相关

• 虚拟机会收集类及父类中的类变量及类方法组合为< clinit>方法，根据定义的顺序进行初始化。虚拟机会保证子类的< clinit>执行之前，父类的< clinit>方法先执行完毕。因此，虚拟机中第一个被执行完毕的< clinit>方法肯定是java.lang.object方法。

public class test {
    static int a = 10;
    static {
        a = 20;
    }
}

class test1 extends test {
    private static int b = a;
    public static void main(string[] args) {
        system.out.println(test1.b);
    }
}
//输出结果
//20

从输出中看出，父类的静态初始化块在子类静态变量初始化之前初始化完毕，所以输出结果是20，不是10。

• 如果类或者父类中都没有静态变量及方法，虚拟机不会为其生成< clinit>方法。

• 接口与类不同的是，执行接口的＜clinit＞方法不需要先执行父接口的＜clinit＞方法。 只有当父接口中定义的变量使用时，父接口才会初始化。 另外，接口的实现类在初始化时也一样不会执行接口的＜clinit＞方法。

public interface interfaceinittest {
    long a = currenttime.gettime();

}

interface interfaceinittest1 extends interfaceinittest {
    int b = 100;
}

class interfaceinittestimpl implements interfaceinittest1 {
    public static void main(string[] args) {
        system.out.println(interfaceinittestimpl.b);
        system.out.println("---------------------------");
        system.out.println("当前时间："+interfaceinittestimpl.a);
    }
}

class currenttime {
    static long gettime() {
        system.out.println("加载了interfaceinittest接口");
        return system.currenttimemillis();
    }
}
//输出结果
//100
//---------------------------
//加载了interfaceinittest接口
//当前时间：1560158880660

从输出验证了：对于接口，只有真正使用父接口的类变量才会真正的加载父接口。这跟普通类加载不一样。

• 虚拟机会保证一个类的< clinit>方法在多线程环境中被正确地加锁和同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的< clinit>方法，其他线程都需要阻塞等待，直到活动线程执行< clinit>方法完毕。

public class multithreadinittest {
    static int a = 10;
    static {
           system.out.println(thread.currentthread()+"init multithreadinittest");
        try {
            timeunit.seconds.sleep(10);
        } catch (interruptedexception e) {
            e.printstacktrace();
        }
    }

    public static void main(string[] args) {
        runnable runnable = () -> {
            system.out.println(thread.currentthread() + "start");
            system.out.println(multithreadinittest.a);
            system.out.println(thread.currentthread() + "run over");
        };
        thread thread1 = new thread(runnable);
        thread thread2 = new thread(runnable);
        thread1.start();
        thread2.start();
    }
}
//输出结果
//thread[main,5,main]init multithreadinittest
//thread[thread-0,5,main]start
//10
//thread[thread-0,5,main]run over
//thread[thread-1,5,main]start
//10
//thread[thread-1,5,main]run over

从输出中看出验证了：只有第一个线程对multithreadinittest进行了一次初始化，第二个线程一直阻塞等待等第一个线程初始化完毕。

3.2、类初始化时机

1. 当虚拟机启动时，初始化用户指定的主类；
2. 当遇到用以新建目标类实例的new指令时，初始化new指令的目标类；
3. 当遇到调用静态方法或者使用静态变量，初始化静态变量或方法所在的类；
4. 子类初始化过程会触发父类初始化；
5. 如果一个接口定义了default方法，那么直接实现或者间接实现该接口的类的初始化，会触发该接口初始化；
6. 使用反射api对某个类进行反射调用时，初始化这个类；
7. class.forname()会触发类的初始化

3.3、final定义的初始化

注意：对于一个使用final定义的常量，如果在编译时就已经确定了值，在引用时不会触发初始化，因为在编译的时候就已经确定下来，就是“宏变量”。如果在编译时无法确定，在初次使用才会导致初始化。

public class staticinnersingleton {
    /**
     * 使用静态内部类实现单例：
     * 1：线程安全
     * 2：懒加载
     * 3：非反序列化安全，即反序列化得到的对象与序列化时的单例对象不是同一个，违反单例原则
     */
    private static class lazyholder {
        private static final staticinnersingleton inner_singleton = new staticinnersingleton();
    }

    private staticinnersingleton() {
    }

    public static staticinnersingleton getinstance() {
        return lazyholder.inner_singleton;
    }
}

看这个例子，单例模式静态内部类实现方式。我们可以看到单例实例使用final定义，但在编译时无法确定下来，所以在第一次使用staticinnersingleton.getinstance()方法时，才会触发静态内部类的加载，也就是延迟加载。这里想指出，如果final定义的变量在编译时无法确定，则在使用时还是会进行类的初始化。

3.4、classloader只会对类进行加载，不会进行初始化

public class tester {
    static {
        system.out.println("tester类的静态初始化块");
    }
}

class classloadertest {
    public static void main(string[] args) throws classnotfoundexception {
        classloader classloader = classloader.getsystemclassloader();
        //下面语句仅仅是加载tester类
        classloader.loadclass("loader.tester");
        system.out.println("系统加载tester类");
        //下面语句才会初始化tester类
        class.forname("loader.tester");
    }
}
//输出结果
//系统加载tester类
//tester类的静态初始化块

从输出证明：classloader只会对类进行加载，不会进行初始化；使用class.forname()会强制导致类的初始化。

三、类加载器

类加载器负责将.class文件（不管是jar,还是本地磁盘，还是网络获取等等）加载到内存中，并为之生成对应的java.lang.class对象。一个类被加载到jvm中，就不会第二次加载了。

那怎么判断是同一个类呢？

每个类在jvm中使用全限定类名（包名+类名）与类加载器联合为唯一的id，所以如果同一个类使用不同的类加载器，可以被加载到虚拟机，但彼此不兼容。

1、jvm类加载器分类

1.1、bootstrap classloader

bootstrap classloader为根类加载器，负责加载java的核心类库。根加载器不是classloader的子类，是有c++实现的。

public class bootstraptest {
    public static void main(string[] args) {
        //获取根类加载器所加载的全部url数组
        url[] urls = launcher.getbootstrapclasspath().geturls();
        arrays.stream(urls).foreach(system.out::println);
    }
}
//输出结果
//file:/c:/sorftwareinstall/java/jdk/jre/lib/resources.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/rt.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/sunrsasign.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/jsse.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/jce.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/charsets.jar
//file:/c:/sorftwareinstall/java/jdk/jre/lib/jfr.jar
//file:/c:/sorftwareinstall/java/jdk/jre/classes

根类加载器负责加载%java_home%/jre/lib下的jar包（以及由虚拟机参数 -xbootclasspath 指定的类）。

我们将rt.jar解压，可以看到我们经常使用的类库就在这个jar包中。

1.2 、extension classloader

extension classloader为扩展类加载器，负责加载%java_home%/jre/ext或者java.ext.dirs系统熟悉指定的目录的jar包。大家可以将自己写的工具包放到这个目录下，可以方便自己使用。

1.3、 system classloader

system classloader为系统（应用）类加载器，负责加载加载来自java命令的-classpath选项、java.class.path系统属性，或者classpath环境变量所指定的jar包和类路径。程序可以通过classloader.getsystemclassloader()来获取系统类加载器。如果没有特别指定，则用户自定义的类加载器默认都以系统类加载器作为父加载器。

四、类加载机制

1.1、jvm主要的类加载机制。

1. 全盘负责：当一个类加载器负责加载某个class时，该class所依赖和引用的其他class也由该类加载器负责载入，除非显示使用另一个类加载器来载入。
2. 父类委托（双亲委派）：先让父加载器试图加载该class，只有在父加载器无法加载时该类加载器才会尝试从自己的类路径中加载该类。
3. 缓存机制：缓存机制会将已经加载的class缓存起来，当程序中需要使用某个class时，类加载器先从缓存区中搜寻该class，只有当缓存中不存在该class时，系统才会读取该类的二进制数据，并将其转换为class对象，存入缓存中。这就是为什么更改了class后，需要重启jvm才生效的原因。

注意：类加载器之间的父子关系并不是类继承上的父子关系，而是实例之间的父子关系。

public class classloaderproptest {
    public static void main(string[] args) throws ioexception {
        //获取系统类加载器
        classloader systemclassloader = classloader.getsystemclassloader();
        system.out.println("系统类加载器：" + systemclassloader);
        /*
        获取系统类加载器的加载路径——通常由classpath环境变量指定，如果操作系统没有指定
        classpath环境变量，则默认以当前路径作为系统类加载器的加载路径
         */
        enumeration<url> eml = systemclassloader.getresources("");
        while (eml.hasmoreelements()) {
            system.out.println(eml.nextelement());
        }
        //获取系统类加载器的父类加载器，得到扩展类加载器
        classloader extensionloader = systemclassloader.getparent();
        system.out.println("系统类的父加载器是扩展类加载器：" + extensionloader);
        system.out.println("扩展类加载器的加载路径：" + system.getproperty("java.ext.dirs"));
        system.out.println("扩展类加载器的parant：" + extensionloader.getparent());
    }
}
//输出结果
//系统类加载器：sun.misc.launcher$appclassloader@18b4aac2
//file:/c:/projecttest/fengkuang/out/production/fengkuang/
//系统类的父加载器是扩展类加载器：sun.misc.launcher$extclassloader@1540e19d
//扩展类加载器的加载路径：c:\sorftwareinstall\java\jdk\jre\lib\ext;c:\windows\sun\java\lib\ext
//扩展类加载器的parant：null

从输出中验证了：系统类加载器的父加载器是扩展类加载器。但输出中扩展类加载器的父加载器是null，这是因为父加载器不是java实现的，是c++实现的，所以获取不到。但扩展类加载器的父加载器是根加载器。

1.2、类加载流程图

图中红色部分，可以是我们自定义实现的类加载器来进行加载。

五、创建并使用自定义类加载器

1、自定义类加载分析

除了根类加载器，所有类加载器都是classloader的子类。所以我们可以通过继承classloader来实现自己的类加载器。

classloader类有两个关键的方法：

1. protected class loadclass(string name, boolean resolve)：name为类名，resove如果为true，在加载时解析该类。
2. protected class findclass(string name) ：根据指定类名来查找类。

所以，如果要实现自定义类，可以重写这两个方法来实现。但推荐重写findclass方法，而不是重写loadclass方法，因为loadclass方法内部回调用findclass方法。

我们来看一下loadclass的源码

protected class<?> loadclass(string name, boolean resolve)
        throws classnotfoundexception
    {
        synchronized (getclassloadinglock(name)) {
            //第一步，先从缓存里查看是否已经加载
            class<?> c = findloadedclass(name);
            if (c == null) {
                long t0 = system.nanotime();
                try {
                //第二步，判断父加载器是否为null
                    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) {
                   //第三步，如果前面都没有找到，就会调用findclass方法
                    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加载方法流程：

1. 判断此类是否已经加载；
2. 如果父加载器不为null，则使用父加载器进行加载；反之，使用跟加载器进行加载；
3. 如果前面都没加载成功，则使用findclass方法进行加载。

所以，为了不影响类的加载过程，我们重写findclass方法即可简单方便的实现自定义类加载。

2、实现自定义类加载器

基于以上分析，我们简单重写findclass方法进行自定义类加载。

public class hello {
   public void test(string str){
       system.out.println(str);
   }
}

public class myclassloader extends classloader {

    /**
     * 读取文件内容
     *
     * @param filename 文件名
     * @return
     */
    private byte[] getbytes(string filename) throws ioexception {
        file file = new file(filename);
        long len = file.length();
        byte[] raw = new byte[(int) len];
        try (fileinputstream fin = new fileinputstream(file)) {
            //一次性读取class文件的全部二进制数据
            int read = fin.read(raw);
            if (read != len) {
                throw new ioexception("无法读取全部文件");
            }
            return raw;
        }
    }

    @override
    protected class<?> findclass(string name) throws classnotfoundexception {
        class clazz = null;
        //将包路径的(.)替换为斜线(/)
        string filestub = name.replace(".", "/");
        string classfilename = filestub + ".class";
        file classfile = new file(classfilename);

        //如果class文件存在，系统负责将该文件转换为class对象
        if (classfile.exists()) {
            try {
                //将class文件的二进制数据读入数组
                byte[] raw = getbytes(classfilename);
                //调用classloader的defineclass方法将二进制数据转换为class对象
                clazz = defineclass(name, raw, 0, raw.length);
            } catch (ioexception e) {
                e.printstacktrace();
            }
        }
        //如果clazz为null,表明加载失败，抛出异常
        if (null == clazz) {
            throw new classnotfoundexception(name);
        }
        return clazz;
    }

    public static void main(string[] args) throws exception {
        string classpath = "loader.hello";
        myclassloader myclassloader = new myclassloader();
        class<?> aclass = myclassloader.loadclass(classpath);
        method main = aclass.getmethod("test", string.class);
        system.out.println(main);
        main.invoke(aclass.newinstance(), "hello world");
    }
}
//输出结果
//hello world

classloader还有一个重要的方法defineclass(string name, byte[] b, int off, int len)。此方法的作用是将class的二进制数组转换为calss对象。

此例子很简单，我写了一个hello测试类，并且编译过后放在了当前路径下（大家可以在findclass中加入判断，如果没有此文件，可以尝试查找.java文件，并进行编译得到.class文件；或者判断.java文件的最后更新时间大于.class文件最后更新时间，再进行重新编译等逻辑）。

六、总结

本篇从类加载的三大阶段：加载、链接、初始化开始细说每个阶段的过程；详细讲解了jvm常用的类加载器的区别与联系，以及类加载机制流程，最后通过自定义的类加载器例子结束本篇。小弟能力有限，大家看出有问题请指出，让博主学习改正。欢迎讨论啊。

注意：本篇博客总结主要来源。如有转载，请注明出处

1. 《疯狂java讲义（第3版）》
2. 《深入理解java虚拟机++jvm高级特性与最佳实践》