JVM的双亲委派机制以及如何打破？

一、了解双亲委派模型，它所涉及的结构，它的工作过程

        在说这个双亲委派模型之前，先了解Java的类加载器：在Java中系统自带的类加载器有三种：BootstraptClassLoader启动类加载器、ExtClassLoader扩展类加载器、ApplicationClassLoader应用类加载器。同时还可以根据需求，实现自定义类加载器，若是需要实现自定义类加载器的话，是需要继承ClassLoader类重写里面的findClass方法的。

        工作过程：首先对于一个Java源文件进行加载的时候，首先接触的是ApplicationClassLoader应用类加载器，它会去检查是不是已经被加载过了，如果加载了，不再加载；反之没有加载就会去交给父加载器实现加载验证，同理，直到BootStraptClassLoader，他没有父加载器，就会去判断能不能加载处理，如果不能就下放，直到ApplicationClassLoader，如果他还是不能加载的话，就只能抛出ClassNotFoundException异常。

二、了解一下ClassLoader下的loadClass方法的源码

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.
                                        //  如果仍然找不到，则调用findClass以查找该类。
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                                        //  这个类定义了loader；记录数据
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

        从上面的源码和图片的原理图可以看出：假如，我现在有一个HelloWorld.java的源文件，当这个文件被加载的时候，ApplicationClassLoader会去检查是否被加载过，如果加载了，那就不在需要加载了，但是如果没有的话，就交给父加载器进行加载，然后钓鱼竿父加载器的loadClass方法，父加载器也会去检查是否被加载过，如果加载过，就不需要加载，反之，没有加载过的话，就进行交给父加载器进行加载，这个时候就是BootStraptCLassLoader类加载器，这个是没有父加载器的，所以就要判断自己是不是可以处理加载，如果不能，就下放，交给下一层加载器加载，一直到底层ApplicationClassLoader若还是不能进行加载的话，就只能抛出ClassNotFoundException。

        那为啥需要这种机制呢？

        我个人觉得其实是为了代码的安全。假如，我现在写了一个String类，这个String类的全限定名和系统提供的也是一样的，我想试图修改一下JDK的源码，但是最后调用的时候，发现还是JDK的String类，我的String没有用好像，其实，String类已经被BootStraptClassLoader已经加载过了，而在类加载机制中，被一个类加载器加载了，就不能再次加载，所以，也就实现了代码的安全性。

package java.lang;

public class String {
    
    public void HD() {
        System.out.println("测试一下");
    }
    
}

package com.hui;

public class Test {
    public static void main(String[] args) {
        String str = new String();
        str.HD();//方法未找到
    }
}

        

        那双亲委派模型可以打破吗？当然可以

        

        打破双亲委派模型的方式：

        第一、通过自定义类加载器，重写loadClass()方法。

        第二、使用线程上下文类加载器。