JVM

JVM类加载器与双亲委派模型（JDK8）

2021-07-07  本文已影响0人  imchenway

引言

在上文JVM-类加载机制中，描述了在java命令执行后，JVM类加载的整个流程。

  • 在上文中可以看到ClassLoader在java命令执行后起到了承上启下的重要作用
  • 那么JVM中的ClassCloader是如何运行的呢？本文将带你揭开它神秘的面纱

JVM类加载器

什么是类加载器？

虚拟机的设计团队把类加载阶段中的通过类的全限定名去找到对应的Class文件这个动作放到Java虚拟机的外部去实现，为了便于让应用程序自己决定如何去获取所需要的类，实现这个动作的代码模块就叫做“类加载器”。

类与类加载器的关系

类加载器只用于类的加载动作，但是在我们的Java程序中起到的作用却不至于类的加载。在我们比较两个类是否相等时（equals()、isInstance()、关键字instanceof），即使两个类来源于同一个Class文件，被同一个虚拟机加载，当它们的类加载不同时，那么这两个类也会不相等。

package com.imchenway.classload;

import java.io.IOException;
import java.io.InputStream;

/**
 * 类加载器与类的关系
 *
 * @author David Chan
 * @date 2021-07-02
 */
public class ClassLoaderTest {
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        ClassLoader classLoader = new ClassLoader(){
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                InputStream is = getClass().getResourceAsStream(fileName);
                if (is == null) {
                    return super.loadClass(name);
                }
                try {
                    byte[] b = new byte[is.available()];
                    is.read(b);
                    return defineClass(name, b, 0, b.length);
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return super.loadClass(name);
            }
        };

        Object obj = classLoader.loadClass("com.imchenway.classload.ClassLoaderTest").newInstance();
        System.out.println(obj.getClass());
        System.out.println(obj instanceof com.imchenway.classload.ClassLoaderTest);

        System.out.println("ClassLoaderTest classLoader: " + ClassLoaderTest.class.getClassLoader().toString());
        System.out.println("obj classLoader: " + obj.getClass().getClassLoader().toString());
    }
}

输出：

class com.imchenway.classload.ClassLoaderTest
false
ClassLoaderTest classLoader: jdk.internal.loader.ClassLoaders$AppClassLoader@55054057
obj classLoader: com.imchenway.classload.ClassLoaderTest$1@6ff3c5b5

由此可以看到，ClassLoaderTest在启动时由jdk.internal.loader.ClassLoaders$AppClassLoader@55054057所加载，而obj由com.imchenway.classload.ClassLoaderTest$1@6ff3c5b5所加载，所以System.out.println(obj instanceof com.imchenway.classload.ClassLoaderTest);这一行输出的结果为false，因为类的唯一性由是否是同一个类加载器和是否同一个字节码文件同时决定的。

类加载器是如何去加载类的？

双亲委派模型

双亲委派模型工作过程

双亲委派模型.png

当一个类加载器收到了类加载的请求时，首先是交给自己的父类加载器去加载，最终都会到达顶层的引导类加载器，当父类加载器反馈无法完成这个加载请求时，子加载器尝试自己去加载。

为什么需要双亲委派？

  1. 可以避免类的重复加载，当父加载器已经加载过某一个类时，子加载器就不会再重新加载这个类。
  2. 保证应用程序的安全性，防止核心API被篡改。

在类与类加载器的关系中我们证明了一个类的唯一性由加载这个类的类加载器和类本身所决定，如果没有双亲委派机制存在的话，设想如果应⽤程序类加载器想要 加载⼀个有破坏性的java.lang.System类，双亲委派模型会⼀层层向上委派，最终委派给启动类加载器，而启动类加载器中检查到缓存中已经有了这个类，并不会再加载这个有破坏性的System类。

当然，实际上自定义包名java开头的类将无法加载成功
<img src="/images/posts/preDefineClass.png" width="500px">

双亲委派是如何实现的？

    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);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    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) {
                    // 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;
        }
    }
  1. findLoadedClass(name);判断该类是否已经加载，如果加载过，则使用缓存
  2. 如果加载器不为null，则继续调用父类加载器的loadClass(String name, boolean resolve)方法
  3. 如果加载器为null，说明当前为引导类加载器（bootstrapClassLoader），在findBootstrapClassOrNull(name)中调用本地方法（C++实现）

本文总结

相关问题

如何破坏双亲委派模型？

破坏双亲委托模型，只需要在loadClass(String name, boolean resolve) 方法中，不调用父类加载器去加载类就可以了。

为什么要破坏双亲委派模型？

由于类的唯一性由是否是同一个类加载器和是否同一个字节码文件同时决定的这一特性，可以为应用程序提供类库的隔离性。

有哪些破坏了双亲委派模型的例子？分别是为了什么目的？

  1. Tomcat：我们经常会在一个Tomcat中部署多个应用程序，多个应用程序之前可能用着不同版本的类库，也可能共享着一部分类库。这个时候自定类加载器就可以派上用场了
    • 在Tomcat中主要用自定义类加载器解决以下几个问题：
      1. 同一个Tomcat中，各个Web应用之前各自使用的Java类库要互相隔离
      2. 同一个Tomcat中，各个Web应用之间可以共享有共享的Java类库
      3. 为了使Tomcat不受web应用的影响，服务器的类库应该与应用程序的类库互相独立
      4. 使Tomcat支持热部署

Tomcat中类加载器的架构是怎么样的？

Tomcat双亲委派模型.png

CommonClassLoader能加载的类都可以被Catalina ClassLoader和SharedClassLoader使用，从而实现了公有类库的共用，而CatalinaClassLoader和Shared ClassLoader自己能加载的类则与对方相互隔离。
WebAppClassLoader可以使用SharedClassLoader加载到的类，但各个WebAppClassLoader实例之间相互隔离。

上一篇下一篇

猜你喜欢

热点阅读