谈谈双亲委派模型的第四次破坏-模块化

时间 2020-03-31

标签谈谈双亲委派模型第四破坏模块化繁體版

原文原文链接

前言

JDK9引入了Java模块化系统(Java Platform Moudle System)来实现可配置的封装隔离机制，同时JVM对类加载的架构也作出了调整，也就是双亲委派模型的第四次破坏。前三次破坏分别是：双亲委派模型推出以前，SPI机制，以及OSGI为表明的热替换机制，这里不细说。java

双亲委派模型

简介

在JDK9引入以前，绝大多数Java程序会用下面三个类加载器进行加载数据结构

启动类加载器(Bootstrap Class Loader)：由C++编写，负责加载<JAVA_HOME>\jre\lib目录下的类，例如最基本的Object，Integer，这些存在于rt.jar文件中的类，通常这些类都是Java程序的基石。
扩展类加载器(Extension Class Loader)：负责加载<JAVA_HOME>\jre\lib\ext目录下的类，在JDK9以前咱们能够将通用性的类库放在ext目录来扩展JAVA的功能，但实际的工程都是经过maven引入jar包依赖。而且在JDK9取消了这一类加载器，取而代之的是平台类加载器(Platform Class Loader)，下面会对其介绍。
应用类加载器(Application Class Loader)：负责加载ClassPath路径下的类，一般工程师编写的大部分类都是由这个类加载器加载。

工做顺序

解释

若是一个ClassLoader收到了类加载的请求，他会先首先将请求委派给父类加载器完成，只有父类加载器加载不了，子加载器才会完成加载。架构

源代码

下面代码保留了核心逻辑，并添加了注释，主要是2个步骤并发

若是父类加载器不为空则用父类加载器加载
父类加载器加载不成功则自己再加载

Class<?> c = findLoadedClass(name);
            //若是该类没加载过
            if (c == null) {
                try {
                //若是有父类加载器
                    if (parent != null) {
                    //使用父类加载器加载
                        c = parent.loadClass(name, false);
                        ...
                    } 
                } 
                   if (c == null) {
                    ...
                    //父类加载器没有加载成功则调用自身的findClass进行加载
                    c = findClass(name);
										...
                }
            }
       
复制代码

值得注意的是这里的parent并非继承上的父子关系，而是组合关系的父子，parent只是类加载器的一个参数。app

图示

若是以为上面的解释比较抽象能够看看下面比较形象的图示，这里的敌人就是咱们要加载的jar包maven

缺点

经过上面的漫画不言而喻，当真正的敌人来了，靠这种低效的传达机制，怎么可能打一场胜仗呢？模块化

启动类加载器负责加载<JAVA_HOME>\jre\lib目录
扩展类加载器负责加载<JAVA_HOME>\jre\lib\ext目录
应用类加载器负责加载ClassPath目录。

既然一切都是各司其职，为何不能加载类的时候一步到位呢？源码分析

经过分析JDK9的类加载器源码，我发现最新的类加载器结构在必定程度上是缓解了这种状况的ui

JDK的模块化

在JDK9以前，JVM的基础类之前都是在rt.jar这个包里，这个包也是JRE运行的基石。这不只是违反了单一职责原则，一样程序在编译的时候会将不少无用的类也一并打包，形成臃肿。spa

在JDK9中，整个JDK都基于模块化进行构建，之前的rt.jar, tool.jar被拆分红数十个模块，编译的时候只编译实际用到的模块，同时各个类加载器各司其职，只加载本身负责的模块。

模块化加载源码

Class<?> c = findLoadedClass(cn);
      if (c == null) {
         // 找到当前类属于哪一个模块
         LoadedModule loadedModule = findLoadedModule(cn);
         if (loadedModule != null) {
            //获取当前模块的类加载器
            BuiltinClassLoader loader = loadedModule.loader();
            //进行类加载
            c = findClassInModuleOrNull(loadedModule, cn);
         } else {
            // 找不到模块信息才会进行双亲委派
         if (parent != null) {
           c = parent.loadClassOrNull(cn);
         }
       }
复制代码

上面代码就是破坏双亲委派模型的“铁证”，而当咱们继续跟进findLoadedModule，会发现是根据路径名找到对应的模块，而维护这一数据结构的就是下面这个Map。

Map<String, LoadedModule> packageToModule
        = new ConcurrentHashMap<>(1024);
复制代码

能够看到LoadedModule里面不只有该模块的loader信息，还有用于描述依赖模块，对外暴露模块的信息的mref，LoadedModule也是模块化实现封装隔离机制的一块重要实现。

每个module信息都有一个BuiltinClassloader，这个类有三个子类，咱们经过源码分析他们的父子关系

在ClassLoaders类中能够发现，PlatformClassLoader的parent是BootClassLoader，而AppClassLoader的parent则是PlatformClassLoader。

public class ClassLoaders {

    // the built-in class loaders
    private static final BootClassLoader BOOT_LOADER;
    private static final PlatformClassLoader PLATFORM_LOADER;
    private static final AppClassLoader APP_LOADER;

    static {
        BOOT_LOADER =
            new BootClassLoader((append != null && !append.isEmpty())
                ? new URLClassPath(append, true)
                : null);
                
        PLATFORM_LOADER = new PlatformClassLoader(BOOT_LOADER);
        ...
        APP_LOADER = new AppClassLoader(PLATFORM_LOADER, ucp);
    }
  }
复制代码

结论

通过破坏后的双亲委派模型更加高效，减小了不少类加载器之间没必要要的委派操做
JDK9的模块化能够减小Java程序打包的体积，同时拥有更好的隔离线与封装性
每一个moudle拥有专属的类加载器，程序在并发性上也会更加出色
```
若是您以为个人文章有用请点一个赞给予我支持！
复制代码
```