JVM类加载过程与双亲委派模型_双亲委派的翻译是错的么-优快云博客

本文链接：https://blog.youkuaiyun.com/lzxomg/article/details/102602224

“双亲委派"的原文是"parents delegate”。翻译的不准确，大概意思应该是"委托给父辈"。

类加载过程

类加载过程为JVM将类描述数据从.class文件中加载到内存，并对数据进行解析和初始化，最终形成被JVM直接使用的Java类型。此过程包含：

加载：获取该类的二进制字节流，将字节流代表的静态存储结构转化为方法区的运行时数据结构，并在内存生成代表该类的 java.lang.Object 对象作为方法区该类的访问入口
验证：确保 Class 文件的字节流中包含的信息符号当前虚拟机的要求（文件格式验证、元数据验证、字节码验证、符号引用验证）
准备：为类变量分配内存并设置类变量初始值
解析：将常量池内的符号引用替换为直接引用
初始化：执行类构造器 () 方法

类加载器

在类加载过程中的加载操作由类加载器去完成，需要通过一个类的全限定名来获取定义此类的二进制字节流，然后通过一段代码(类加载器)完成加载动作。类加载器分为：

启动类加载器/Bootstrap ClassLoader：负责加载JAVA_HOME/lib目录中的所有类，或者加载由选项-Xbootcalsspath指定的路径下的类；
扩展类加载器/ExtClasLoader：负责加载JAVA_HOME/lib/ext目录中的所有类型，或者由参数-Xbootclasspath指定路径中的所有类型；
应用程序类加载器/AppClassLoader：负责加载用户类路径ClassPath下的所有类型，我们写的代码默认就是由它来加载
自定义加载器：所有继承抽象类java.lang.ClassLoader的类加载器

双亲委派模型

双亲委派过程：当一个类加载器收到类加载任务时，立即将任务委派给它的父类加载器去执行，逐级向上递归，直至找不到父类加载器委派给最顶层的启动类加载器做为父类加载器；如果父类加载器可以完成类加载任务，就成功返回；如果父类加载器无法加载委派给它的类时，父类加载器无法完成此加载任务时，才自己去加载。

在这里插入图片描述
双亲委派模型最大的好处就是让Java类同其类加载器一起具备了一种带优先级的层次关系。举个例子来说明下：比如我们要加载顶层的Java类——java.lang.Object类，无论我们用哪个类加载器去加载Object类，这个加载请求最终都会委托给启动类加载器（Bootstrap ClassLoader），这样就保证了所有加载器加载的Object类都是同一个类。如果没有双亲委派模型，就会出现 Wupx::Object 和 Huyx::Object 这样两个不同的Object类

java.lang.ClassLoader源码

先检查是否已经被加载过，若没有加载则调用父类加载器的loadClass()方法，若父加载器为空则使用启动类加载器作为父加载器。如果父加载失败，则抛出ClassNotFoundException异常后，再调用自己的findClass()方法进行加载。

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) {
                        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) {
                    // 如果仍然没有找到，那么调用自己的findClass()加载
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // 定义类装入器；记录统计信息
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

类加载器与类的唯一性

对于任意一个类，都需要由加载它的类加载器和这个类本身来一同确立其在Java虚拟机中的唯一性。通俗的说，JVM中两个类是否“相等”，首先就必须是同一个类加载器加载的，否则，即使这两个类来源于同一个Class文件，被同一个虚拟机加载，只要类加载器不同，那么这两个类必定是不相等的。

什么意思呢？我们知道，判断一个类是否相同，通常用equals()方法，isInstance()方法和isAssignableFrom()方法来判断。

package test.classload;

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

/**
 * 类加载器在类相等判断中的影响
 * instanceof关键字
 */
public class ClassLoaderTest {
    public static void main(String[] args) throws Exception {
        // 自定义类加载器
        ClassLoader myLoader = new ClassLoader() {
            @Override
            public Class<?> loadClass(String name) throws ClassNotFoundException {
                try {
                    String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
                    InputStream is = getClass().getResourceAsStream(fileName);
                    if (is == null) {
                        return super.loadClass(fileName);
                    }
                    byte[] b = new byte[is.available()];
                    // 将流写入字节数组b中
                    is.read(b);
                    return defineClass(name, b, 0, b.length);   
                } catch (IOException e) {
                    throw new ClassNotFoundException();
                }
            }
        };

        // 使用默认类加载器加载本类
        Object obj1 = ClassLoaderTest.class.getClassLoader().loadClass("test.classload.ClassLoaderTest").newInstance();
        System.out.println(obj1.getClass()); // class test.classload.ClassLoaderTest
        System.out.println(obj1 instanceof test.classload.ClassLoaderTest); // true

        // 使用自定义类加载器加载本类
        Object obj2 = myLoader.loadClass("test.classload.ClassLoaderTest").newInstance();
        System.out.println(obj2.getClass()); // class test.classload.ClassLoaderTest
        System.out.println(obj2 instanceof test.classload.ClassLoaderTest); // false
		
		// ClassLoaderTest obj2Cast = (ClassLoaderTest)obj2;
		// 强转会抛出java.lang.ClassCastException，因为两者不属于同一类加载器加载，所以不能转化！
    }
}

破坏双亲委派

为什么需要破坏双亲委派？
因为在某些情况下父类加载器需要委托子类加载器去加载class文件。受到加载范围的限制，父类加载器无法加载到需要的文件，以Driver接口为例，由于Driver接口定义在jdk当中的，而其实现由各个数据库的服务商来提供，比如mysql的就写了MySQL Connector，那么问题就来了，DriverManager（也由jdk提供）要加载各个实现了Driver接口的实现类，然后进行管理，但是DriverManager由启动类加载器加载，只能记载JAVA_HOME的lib下文件，而其实现是由服务商提供的，由系统类加载器加载，这个时候就需要启动类加载器来委托子类来加载Driver实现，从而破坏了双亲委派，这里仅仅是举了破坏双亲委派的其中一个情况。

ClassLoad其他相关文章