Java ClassLoader 02 -- 双亲委派模式

上一篇：https://blog.csdn.net/fengxianaa/article/details/124449822

为了让之前3个类加载器能够合理的工作，因此有了双亲委派模式。

1. 概念

双亲委派模式：简称：坑爹模式，

即：如果一个类加载器要加载某个类，它并不会自己先去加载，而是让父加载器去加载，

       如果父加载器还有父亲，则进一步向上委托，依次递归，

       最终推给达顶层的启动类加载器(Bootstrap ClassLoader)。

       如果父加载器可以完成加载任务，就成功返回，倘若父加载器无法完成此加载任务，子加载器才会尝试自己去加载。

看下图：

这里要注意：Bootstrap ClassLoader并不是ExtClassLoader的父亲，但可以它看作类加载器届的上帝，所有类的加载都需要先经过Bootstrap ClassLoader，如果加载失败，才自己去加载

2. 源码

加载一个类，最终会走到ClassLoader类中的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 {
                    if (parent != null) {
                    	// 父加载器不为空则调用父加载器的loadClass，
                        // 这里类似递归调用，进去后还是这个方法
                        c = parent.loadClass(name, false);
                    } else {
                    	// 父加载器为空则调用Bootstrap Classloader
                        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();
                    //父加载器没有找到，则调用findclass，自己去加载
                    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;
        }
    }

3. 好处

• 避免类的重复加载
• 保证java核心api不会被随意替换
  • 假设自定义一个名为java.lang.Integer的类，通过双亲委派模式传递到启动类加载器，
  • 启动类加载器在Java 核心类库，就能找到 Integer 类，于是加载，
  • 不会重加载自定义的java.lang.Integer，而直接返回已加载过的Integer.class，这样便可以防止核心API库被随意篡改。

举例说明：

package java.lang;

public class Integer {

    public static void test(){
        System.out.println("test");
    }

    public static void main(String[] args) {
        test();//因为加载得是JDK中的Integer类，所以会报错，提示找不到main方法。
    }
}

输出：

因为加载得是JDK中的Integer类，所以提示找不到main方法。

4. 另一个规则

类的加载还有一个规则：A中使用了B，如果A被AppClassLoader加载，那么B也被 AppClassLoader 加载，但需要注意的是：在加载的时候遵循 坑爹模式。