【从零开始学习JVM | 第四篇】类加载器和双亲委派机制(高频面试题)-CSDN博客

（1）避免类重复加载

若多个类加载器都尝试加载同一个类，会导致内存中存在多个相同类的实例，破坏类型唯一性。双亲委派确保类只被加载一次。

（2）保护核心 API

例如，用户自定义的 java.lang.String 类不会被加载，因为 String 由启动类加载器加载。这防止恶意或错误代码覆盖 JVM 核心类，保障系统安全。

（3）实现类的隔离与模块化

不同类加载器可加载同名但不同路径的类（如插件系统），实现隔离性。例如，Web 容器（如 Tomcat）使用自定义类加载器实现多个应用的隔离。

核心原则：

向上委派：先让父类加载器尝试加载。
向下查找：父类无法加载时，子类再尝试。

工作流程

当类加载器（如 AppClassLoader）收到类加载请求时：

检查缓存：首先检查该类是否已被加载。
委派父类：若未加载，则将请求委派给父类加载器（如 ExtClassLoader）。
递归委派：父类加载器重复步骤 1 和 2，直到到达启动类加载器。
尝试加载：
启动类加载器尝试加载该类，若成功则返回 Class 对象。
若失败，则由扩展类加载器尝试，依此类推，直到子类加载器（如 AppClassLoader）。

抛出异常：若所有类加载器都无法加载，则抛出 ClassNotFoundException。

双亲委派机制源码解读：

`ClassLoader` 的四个核心方法

loadClass：负责整体调度，按层级查找类。
findClass：具体去哪里找类（子类必须实现）。
defineClass：把类文件的二进制内容变成 JVM 能懂的 Class 对象。
resolveClass：解析类的内部结构，确保类能正常工作。

在加载类的时候会调用它，第一个参数是加载的类名，第二个参数是否需要解析类

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
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

代码流程：

获取加载的类，如果为空说明没有加载。
进入第一个if，判断有无父类加载器，有就调用父类加载器加载。
没有父类加载器说明需要用启动类加载器加载。
第二个if表示父类加载器加载失败，则调用此时的子类加载器加载。

我们来看看findclass方法的源码

protected Class<?> findClass(String name) throws ClassNotFoundException {

        int index = name.indexOf(';');
        String cookie = "";
        if(index != -1) {
                cookie = name.substring(index, name.length());
                name = name.substring(0, index);
        }

        // check loaded JAR files
        try {
            return super.findClass(name);
        } catch (ClassNotFoundException e) {
        }

        // Otherwise, try loading the class from the code base URL

        // 4668479: Option to turn off codebase lookup in AppletClassLoader
        // during resource requests. [stanley.ho]
        if (codebaseLookup == false)
            throw new ClassNotFoundException(name);

//      final String path = name.replace('.', '/').concat(".class").concat(cookie);
        String encodedName = ParseUtil.encodePath(name.replace('.', '/'), false);
        final String path = (new StringBuffer(encodedName)).append(".class").append(cookie).toString();
        try {
            byte[] b = AccessController.doPrivileged(
                               new PrivilegedExceptionAction<byte[]>() {
                public byte[] run() throws IOException {
                   try {
                        URL finalURL = new URL(base, path);

                        // Make sure the codebase won't be modified
                        if (base.getProtocol().equals(finalURL.getProtocol()) &&
                            base.getHost().equals(finalURL.getHost()) &&
                            base.getPort() == finalURL.getPort()) {
                            return getBytes(finalURL);
                        }
                        else {
                            return null;
                        }
                    } catch (Exception e) {
                        return null;
                    }
                }
            }, acc);

            if (b != null) {
                return defineClass(name, b, 0, b.length, codesource);
            } else {
                throw new ClassNotFoundException(name);
            }
        } catch (PrivilegedActionException e) {
            throw new ClassNotFoundException(name, e.getException());
        }
    }

核心问题

什么是双亲委派机制?

1.在一个类加载器去加载一个类的时候，会自下而上去查找这个类有没有被加载过，如果都没有加载，就会自上而下去加载这个类，如果都无法加载就会抛出异常。

2.应用类加载器的父类是扩展类加载器，扩展类加载器的父类是启动类加载器。

3.双亲委派机制的核心是第一个确保类不会被重复加载，第二个避免恶意代码替换JDK的核心类库，保证核心类库的安全和完整。

总结

双亲委派机制是 Java 安全模型的基石，它通过层级委派和缓存机制确保类的唯一性和安全性。理解该机制有助于排查类加载异常（如 NoClassDefFoundError），并设计出更健壮的框架和应用。

我在学到defineClass的时候有一点疑问，在源代码执行过程中就已经编译成为了class文件，为什么还需要defineClass后来我发现，编译后的是class文件是二进制形式的，而defineClass是把它转换为JVM能识别的class对象。虽然都是class但是内容形式并不一样。

这也体现了写博客的好处，方便查漏补缺，感谢你们的阅读，你的阅读和点赞是我最大的动力。