【教3妹学java-JVM】8.双亲委派模型-CSDN博客

本文链接：https://blog.csdn.net/kangbin825/article/details/125362032

3妹：2哥，今天是星期天，走，请你下馆子吃大餐怎么样。
2哥：哇哦，看来今天3妹很开发哈？
3妹：是的，今天系统学习了双亲委派模型。
2哥：好啊，现在离晚饭时间还早，那你给我讲讲什么是双亲委派模型？
3妹：哈哈，今天轮到我给你上课了吧。我要从以下几个方面来介绍：

什么是双亲委派模型？
为什么要用双亲委派模型？
怎样破坏双亲委派模型？

什么是双亲委派模型？

就是类加载器一共有三种：

启动类加载器：主要是在加载JAVA_HOME/lib目录下的特定名称jar包，例如rt.jar包，像java.lang就在这个jar包中。
扩展类加载器：主要是加载JAVA_HOME/lib/ext目录下的具备通用性的类库。
应用程序类加载器：加载用户类路径下所有的类库，也就是程序中默认的类加载器。

工作流程：

除启动类加载器以外，所有类加载器都有自己的父类加载器，类加载器收到一个类加载请求时，首先会判断类是否已经加载过了，没有的话会调用父类加载器的的loadClass方法，将请求委派为父加载器，当父类加载器无法完成类加载请求时，子加载器才尝试去加载这个类。目的是为了保证每个类只加载一次，并且是由特定的类加载器进行加载（都是首先让启动类来进行加载）。

public abstract class ClassLoader {
    ...
    public Class<？> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
    protected Class<？> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
          //使用synchronized加锁，保证不会重复加载
        synchronized (getClassLoadingLock(name)) {
          //判断这个类是否已加载
            Class<？> c = findLoadedClass(name);
            if (c == null) {
                ...
                try {
                    if (parent != null) {//有父类加载器，让父类加载器先尝试加载
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                }
                                //使用当前类加载器进行类加载
                if (c == null) {
                    ...
                    c = findClass(name);
                    // do some stats
                    ...
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }
    protected Class<？> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
    ...
}

为什么要用双亲委派模型？

一，避免类重复加载；
比如即使我们已经定义了java.lang.Object的Java文件，但其实也无法加载，因为java.lang.Object已经被启动类加载器加载了。

二，安全性，避免核心类被修改。
假设我现在创建一个java.lang.Object的Java文件，然后在里面植入一些病毒木马，或者写一些死循环在构造方法中。对JVM来说，这是致命的。

怎样破坏双亲委派模型？

双亲委派模型，JVM并没有强制要求遵守，只是说推荐。
要想破坏它，只要使得父类加载器调用子类加载器去加载类，这便破坏了双亲委派模型。

以mysql.jdbc.Driver来讲解：

第一种：不破坏双亲委派模型

自定义的Java类

         // 1.加载数据访问驱动
        Class.forName("com.mysql.jdbc.Driver");
        //2.连接到数据"库"上去
        Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?characterEncoding=GBK", "root", "");

分析一下这2行代码：
第一行：进行类加载，还记得上面说过Class.forName()会使用当前的类加载器来加载对应的类。当前的类，就是用户写的Java类，用户写的Java类使用应用程序类加载器加载的。那现在问题就是应用程序类加载器是否能加载com.mysql.jdbc.Driver这个类，答案是可以的。因此这种方式加载类，是不会破坏双亲委派模型的。
第二行：就是通过遍历的方式，来获取MySQL驱动的具体连接。

第二种：破坏双亲委派模型

在JDBC4.0以后，开始支持使用spi的方式来注册这个Driver，具体做法就是在mysql的jar包中的META-INF/services/java.sql.Driver 文件中指明当前使用的Driver是哪个，然后使用的时候就直接这样就可以了：

 Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb?characterEncoding=GBK", "root", "");

这和不破坏双亲委派模型的代码有啥区别：就是少了Class.forName(“com.mysql.jdbc.Driver”)这一行。

public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    public Driver() throws SQLException {
    }

    static {
        try {
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
}

因为少了Class.forName()，因为就不会触发Driver的静态代码块，进而少了注册的过程。

现在，我们分析下看使用了这种spi服务的模式原本的过程是怎样的:

第一，从META-INF/services/java.sql.Driver文件中获取具体的实现类名“com.mysql.jdbc.Driver”
第二，加载这个类，这里肯定只能用class.forName(“com.mysql.jdbc.Driver”)来加载。

好了，问题来了，现在这个调用者是DriverManager，加载DriverManager在rt.jar中，rt.jar是被启动类加载器加载的。还记得上面Class.forName()会使用当前的类加载器来加载对应的类。也就是说，启动类加载器会去加载com.mysql.jdbc.Driver,但真的可以加载得到吗？很明显不可以，为什么？因为om.mysql.jdbc.Driver肯定不在<JAVA_HOME>/lib下，所以肯定启动类加载器是无法加载com.mysql.jdbc.Driver这个类。这就是双亲委派模型的局限性：父类加载器无法加载子类加载器路径中的类。

问题我们定位出来了，接下来该如何解决？

我们分析一下，列出来：

一，可以肯定com.mysql.jdbc.Driver，只能由应用程序类加载器加载。
二，我们需要使用启动类加载器去获取应用程序类加载器，进而通过应用程序类加载器去加载com.mysql.jdbc.Driver。
那么问题就变为了：如何让启动类加载器去获取应用程序类加载器？

为了解决上述的问题，我们需要引入一个新概念：线程上下文类加载器

线程上下文类加载器（ThreadContextClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoaser()方法进行设置，如果创建线程时还未设置，它将会从父线程中继承一个；如果在应用程序的全局范围内都没有设置过，那么这个类加载器默认就是应用程序类加载器。

线程上下文加载器：可以让父类加载器通过调用子类加载器去加载类。

这里得注意一下：我们之前定义的双亲委派模型是：子类加载器调用父类加载器去加载类。现在相反了，换句说，其实已经破坏了双亲委派模型。