双亲委派机制

一、什么是双亲委派机制

每个类加载器都有自己的一个加载路径，当某个类加载器需要加载某个.class文件时，它不是立刻从自己的加载路径中去找这个class文件，而是委派给它的父类加载器去加载。它的父类加载器又委派给父类的父类加载器去加载。

复制代码

这里类加载其实就有一个双亲委派机制，加载某个类时会先委托父加载器寻找目标类，找不到再委托上层父加载器加载，如果所有父加载器在自己的加载类路径下都找不到目标类，则在自己的类加载路径中查找并载入目标类。
比如我们的Math类，最先会找应用程序类加载器加载，应用程序类加载器会先委托扩展类加载
器加载，扩展类加载器再委托引导类加载器，顶层引导类加载器在自己的类加载路径里找了半天没找到Math类，则向下退回加载Math类的请求，扩展类加载器收到回复就自己加载，在自己的类加载路径里找了半天也没找到Math类，又向下退回Math类的加载请求给应用程序类加载器，应用程序类加载器于是在自己的类加载路径里找Math类，结果找到了就自己加载了。。

双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

我们来看下应用程序类加载器AppClassLoader加载类的双亲委派机制源码，AppClassLoader

的loadClass方法最终会调用其父类ClassLoader的loadClass方法，该方法的大体逻辑如下：

1. 首先，检查一下指定名称的类是否已经加载过，如果加载过了，就不需要再加载，返回。

2. 如果此类没有加载过，那么，再判断一下是否有父加载器；如果有父加载器，则由

父加
载器加载（即调用parent.loadClass(name, false);）.或者是调用bootstrap类加载器来
加载。

3. 如果父加载器及bootstrap类加载器都没有找到指定的类，那么调用当前类加载器的

findClass方法来完成类加载。
如何从源码角度打破双亲委派机制，就要从源码看起。

//ClassLoader的loadClass方法，里面实现了双亲委派机制


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) {


// If still not found, then invoke findClass in order


// to find the class.



long t1 = System.nanoTime();


//都会调用URLClassLoader的findClass方法在加载器的类路径里查找并加载该类

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;

}
}
复制代码

自定义类加载器示例：

自定义类加载器只需要继承 java.lang.ClassLoader 类，该类有两个核心方法，一个是

loadClass(String, boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空

方法，所以我们自定义类加载器主要是重写findClass方法。

ublic class MyClassLoaderTest {



static class MyClassLoader extends ClassLoader {



private String classPath;


public MyClassLoader(String classPath) {


this.classPath = classPath;

}

private byte[] loadByte(String name) throws Exception {

name = name.replaceAll("\\.", "/");

FileInputStream fis = new FileInputStream(classPath + "/" + name

+ ".class");
int len = fis.available();


byte[] data = new byte[len];


fis.read(data);


fis.close();


return data;


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

try {


byte[] data = loadByte(name);



return defineClass(name, data, 0, data.length);



} catch (Exception e) {



e.printStackTrace();


throw new ClassNotFoundException();

}

}
/**

* 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载


* @param name


* @param resolve


* @return


* @throws ClassNotFoundException

*/


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) {


// If still not found, then invoke findClass in order


// to find the class.


long t1 = System.nanoTime();



//非自定义的类还是走双亲委派加载


if (!name.startsWith("com.tuling.jvm")){


c = this.getParent().loadClass(name);


}else{

c = findClass(name);


}

// this is the defining class loader; record the stats

sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);

sun.misc.PerfCounter.getFindClasses().increment();

}



if (resolve) {


resolveClass(c);62

}

return c;
}

}

}
public static void main(String args[]) throws Exception {


MyClassLoader classLoader = new MyClassLoader("D:/test");



Class clazz = classLoader.loadClass("com.dzw.jvm.User1");


Object obj = clazz.newInstance();



Method method= clazz.getDeclaredMethod("sout", null);


method.invoke(obj, null);


System.out.println(clazz.getClassLoader());

System.out.println();


MyClassLoader classLoader1 = new MyClassLoader("D:/test1");

Class clazz1 = classLoader1.loadClass("com.dzw.jvm.User1");


Object obj1 = clazz1.newInstance();


Method method1= clazz1.getDeclaredMethod("sout", null);


method1.invoke(obj1, null);


System.out.println(clazz1.getClassLoader());

}
}

复制代码

运行结果：

=======自己的加载器加载类调用方法=======

com.dzw.MyClassLoaderTest$MyClassLoader@890474n2

=======另外一个User1版本：自己的加载器加载类调用方法=======

com。dzw.MyClassLoaderTest$MyClassLoader@90d3y617

重写完jdk源码，我们就实现打破双亲委派