JVM类加载机制和双亲委派机制

博客

JVM

发布日期: 2020-12-07

更新日期: 2020-12-07

文章字数: 951

阅读时长: 3 分

阅读次数:

JVM 类加载流程

其中classLoader.loadClass 分如下7步：
加载>验证>准备>解析>初始化>使用>卸载

加载：再硬盘上通过io读入字节码文件，使用类时才会加载。比如：调用main方法\new一个对象等。加载过程中会在内存中生成一个class对象，作为后续操作的入口。
验证：验证字节码文件的是否正确
准备：给类的静态变量分配内存空间，并赋予默认值
解析：将符号引用替换成直接引用的过程。（将一些静态方法替换成指向内存的指针或句柄）。
初始化：给类的静态变量赋值，加载静态方法。

类被加载到方法区中后主要包含运行时常量池、类型信息、字段信息、方法信息、类加载器的引用、对应class实例的引用等信息。

主类在运行过程中如果使用到其它类，会逐步加载这些类。jar包或war包里的类不是一次性全部加载的，是使用到时才加载。

类加载器和双亲委派机制

类加载器

引导类加载器：负责加载支撑jvm运行的核心类（jdk lib目录下的核心包）
拓展类加载器：负责加载jdk 下的 lib/ext目录下的jar。
应用程序类加载器：负责加载自己引入的 jar 和项目中自定义的类。

双亲委派机制

*源码

ClassLoader.loadClass() 方法

 protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // 首先检查这个class是否被当前加载器加载过。
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        // 如果没有，检查父加载器是否加载过
                        c = parent.loadClass(name, false);
                    } else {
                        // 由于引导类加载器 由c++实现，所以拓展类加载器的parent 无法识别，其实就是引导类加载器。 
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // 如果所有加载器都没有加载过，则先由引导类加载器尝试加载
                    // 加载顺序：引导类加载器》拓展类加载器》应用程序类加载器》自定义类加载器
                    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;
        }
    }

以上代码一句话归结就是：先找父亲加载，失败再由儿子加载。

如果想要分版本加载全限定名相同的类，需要打破双亲委派机制，如同一个容器中，需要加载不同版本的spring。

如何打破双亲委派机制？

继承 ClassLoader 并重写 loadClass 方法

例如

public class MyClassLoader extends ClassLoader{

    @Override
    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);
            long t0 = System.nanoTime();
            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;
        }
    }
}