JVM类加载机制详解-20160812

JVM类加载机制

一，类加载器体系
    类加载器是沙箱的第一道防线，毕竟代码都是类加载器装入到JVM的。类加载体系通过使用不同的类加载器把类放
入不同的命名空间中，从而保护善意代码不受恶意代码的干扰。JVM为每一个类加载器维护一个命名空间，同一个命名
空间中的类的名称不能重复，也就是一个命名空间下，只能有一个
Test.class。
    在JVM中，同一个命名空间中的类，是可以相互交互的，而不同命名空间下的类就不行，除非使用其他的机制。这
样，命名空间就起到了一个屏障的作用。
    通常，一个类加载器，要加载自定义的Class文件时，它必须要依赖其他的类加载器来完成任务，至少需要一个在
JVM启动时创建的类加载器，这个类加载器，我们称之为启动类加载器。在JDK2中，一个类加载器要求另一个类加载器
加载某个类型的过程被规范化为代理模式。在某个类视图以自己的方式加载某个类时，它首先缺省把这个工作交给自己
的父类。而这个父类又会把自己的任务交给自己的父类来处理。这样以来，任务最终都会传到启动类加载器，因为启动
类加载器通常是代理链的最后一个类。如果父类加载器能够加载这个类，就会亲自加载这个类，否则返回给子类加载器
来处理。
    有了上面的理论基础，我们来看类加载器是如何保护可信库（trusted libraries）的。例如，我们试图通过自定
义的类加载器来加载一个类：ConcurrentHashMap，链上的类加载器会依次交给父类来进行检查，这样自定义的类加载
器，始终处于最低优先级，因为ConcurrentHashMap是java.util.concurrent包下的类，因此，启动类加载器会加载这
个类，也就是说最后使用的是启动类加载器加载的这个ConcurrentHashMap，而不是由自定义的类加载器来加载
ConcurrentHashMap。这样就很好的保护了可信库。
    再来看另外一个问题：如果我想把一个自定义的类MyConcurrentHashMap，放到java.util.concurrent包下，可以
实现吗？答案是不可以实现的。当使用自定义的类加载器，强行用defineClass()方法去加载一个以
java.util.concurrent开头的类时，虚拟机会抛出异常：

java.lang.SecurityException:Prohibited package name:java.lang

二，什么是类加载机制
    JVM把描述类的数据，从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被JVM直接
使用的Java类型，这就是JVM的类加载机制。

三，类加载的时机
    类从被加载到JVM内存开始到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）
、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）、卸载（Unloading）。
其中验证、准备、解析这三个部分统称为连接，英文：Linking。
对于类的初始化时机，JVM做了严格规定，在以下5种情况下，必须立即对类进行初始化：
第一种：遇到new、getstatic、putstatic、invokestatic这4条字节码指令时，如果类还没有被初始化，则需要先触发
器初始化。生成这4条指令的最常见的场景是：使用new关键字创建对象的时候，读取或者设置一个类的静态字段的时候
，调用一个静态方法的时候。
第二种：使用java.lang.reflect包的方法对类进行反射调用的时候，如果类还没有初始化，则必须先触发其初始化。
第三种：当初始化一个类的时候，如果发现其父类还没有进行初始化，则需要先触发其父类的初始化。
第四种：当JVM启动时，用户需要指定一个执行的主类，就是包含main方法的那个类，虚拟机必须先初始化这个主类。
第五种：当使用JDK的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果为
REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类还没有进行初始化，则
必须先触发其初始化。
以上5种场景中的行为，称为对一个类的主动引用。除此之外，所有其他的类的引用都不会触发初始化，称为被动引
用。下面举例说明什么是被动引用。
首先写2个类，一个父类，一个子类，2者之间是继承关系：

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class StaticTest_SuperClass {
	// 日志
	final static Log log = LogFactory.getLog(StaticTest_SuperClass.class);
	// 静态代码块
	static{
		log.info("父类中的静态代码块");
	}
	// 静态变量
	public static int COUNT = 1;
	// 普通方法
	public void printTestMethod(){
		log.info("StaticTest_SuperClass类中的普通方法printTestMethod");
	}
}

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
public class StaticTest_SubClass extends StaticTest_SuperClass{
	final static Log log = LogFactory.getLog(StaticTest_SubClass.class);
	static{
		log.info("子类中的静态代码块");
	}
	public static int COUNT = 2;
}

测试类：StaticTest_2

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 第一种：遇到new、getstatic、putstatic、invokestatic这4条字节码指令时，
 * 如果类还没有被初始化，则需要先触发器初始化。
 *
 */
public class StaticTest_2 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		// 使用new关键字创建对象的时候
		StaticTest_SuperClass staticTest_SuperClass = new StaticTest_SuperClass();

		/**
		 * 控制台打印：
		 * 
		 * 2016-8-9 10:21:26 com.yangcq.jvm.StaticTest_SuperClass <clinit>
         * 信息: 父类中的静态代码块
         * 
		 */
	}
}

测试类：StaticTest_1

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 第三种：当初始化一个类的时候，如果发现其父类还没有进行初始化，
 * 则需要先触发其父类的初始化。
 *
 */
public class StaticTest_1 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		log.info("StaticTest_SuperClass.count = " + StaticTest1_SubClass.str);

		/**
		 * 控制台打印：
		 * 
         * 2016-8-9 11:05:24 com.yangcq.jvm.StaticTest1_SuperClass <clinit>
         * 信息: 父类中的静态代码块
         * 2016-8-9 11:05:24 com.yangcq.jvm.StaticTest1_SubClass <clinit>
         * 信息: 子类中的静态代码块
         * 2016-8-9 11:05:24 com.yangcq.jvm.StaticTest_1 main
         * 信息: StaticTest_SuperClass.count = yangcq
         * 
		 */
	}
}

class StaticTest1_SubClass extends StaticTest1_SuperClass{
	final static Log log = LogFactory.getLog(StaticTest_SubClass.class);
	static{
		log.info("子类中的静态代码块");
	}
	public static String str = "yangcq";
}

class StaticTest1_SuperClass {
	final static Log log = LogFactory.getLog(StaticTest_SuperClass.class);
	static{
		log.info("父类中的静态代码块");
	}
	public static String str = "ycq";
}

测试类：StaticTest_3

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 通过数组定义来引用类，不会触发该类的初始化
 *
 */
public class StaticTest_3 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		// 通过数组定义来引用类，不会触发该类的初始化
		StaticTest_SuperClass[] staticTest_SuperClass = new StaticTest_SuperClass[5];
		// StaticTest_SuperClass的类加载器：sun.misc.Launcher$AppClassLoader@addbf1
		log.info("StaticTest_SuperClass的类加载器：" + 
		staticTest_SuperClass.getClass().getClassLoader());
		
		/**
		 * 控制台打印：
		 * 
		 * 2016-8-9 11:07:24 com.yangcq.jvm.StaticTest_3 main
		 * 信息: StaticTest_SuperClass的类加载器：sun.misc.Launcher$AppClassLoader@addbf1
		 * 
		 */
	}
}

测试类：StaticTest_4

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 第三种：当初始化一个类的时候，如果发现其父类还没有进行初始化，
 * 则需要先触发其父类的初始化。
 *
 */
public class StaticTest_4 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		// 初始化子类 StaticTest_SubClass
		StaticTest_SubClass staticTest_SubClass = new StaticTest_SubClass();
		staticTest_SubClass.printTestMethod();
		// StaticTest_SuperClass的类加载器：sun.misc.Launcher$AppClassLoader@addbf1
		log.info("StaticTest_SuperClass的类加载器：" + staticTest_SubClass.getClass().getClassLoader());
		
		/**
		 * 控制台打印：
		 *
		 * 2016-8-9 10:15:57 com.yangcq.jvm.StaticTest_SuperClass <clinit>
		 * 信息: 父类中的静态代码块
		 * 2016-8-9 10:15:57 com.yangcq.jvm.StaticTest_SubClass <clinit>
		 * 信息: 子类中的静态代码块
		 * 2016-8-9 10:15:57 com.yangcq.jvm.StaticTest_SuperClass printTestMethod
		 * 信息: StaticTest_SuperClass类中的普通方法printTestMethod
		 * 2016-8-9 10:15:57 com.yangcq.jvm.StaticTest_4 main
		 * 信息: StaticTest_SuperClass的类加载器：sun.misc.Launcher$AppClassLoader@addbf1
		 *  
		 */
	}
}

测试类：StaticTest_5

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 被动使用类字段示例
 * @description 常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用
 * 到定义常量的类，因此不会触发类的初始化。
 *
 */
public class StaticTest_5 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		// 引用父类StaticTest_SuperClass中定义的静态变量，
		// 不会触发StaticTest_SuperClass_5的初始化
		// 所以不会打印StaticTest_SuperClass_5类中静态代码块中的内容
		log.info("StaticTest_SuperClass_5.str = " + StaticTest_SuperClass_5.str);
		
		/**
		 * 控制台打印：
		 *
		 * 2016-8-9 10:48:15 com.yangcq.jvm.StaticTest_5 main
		 * 信息: StaticTest_SuperClass_5.str = StaticTest_SuperClass_5
		 * 
		 */
		
		/**
		 * 分析：
		 * 
		 * 在编译阶段，通过常量传播优化，已经将常量str的值存储到了StaticTest_SuperClass_5类
		 * 的常量池中。以后StaticTest_SuperClass_5对常量池的引用，实际上转换成了StaticTest_SuperClass_5
		 * 对自己常量池的引用。也就是说StaticTest_SuperClass_5类中并没有StaticTest_5类的符号
		 * 引用入口，这2个类在编译以后，就不存在任何联系了。
		 * 
		 */
	}
}

class StaticTest_SuperClass_5 {
	// 日志
	final static Log log = LogFactory.getLog(StaticTest_SuperClass.class);
	// 静态代码块
	static{
		log.info("父类中的静态代码块");
	}
	// 静态变量
	public static final String str = "StaticTest_SuperClass_5";
}

四，常见的类加载器
启动类加载器（Bootstrap ClassLoader），负责将存放在JAVA_HOME/lib下的，或者被-Xbootclasspath参数所指定
的路径中的，并且是虚拟机识别的类库加载到虚拟机内存中。启动类加载器无法被Java程序直接引用。
扩展类加载器（Extension ClassLoader），负责将存放在JAVA_HOME/lib/ext目录中，或者被java.ext.dirs系统变
量所指定的路径中的所有类库，开发者可以直接使用扩展扩展类加载器。
应用程序类加载器（Application ClassLoader），这个加载器是ClassLoader中getSystemClassLoader()的返回值，
所以一般也称它为系统类加载器。它负责加载用户类路径（Classpath）上所指定的类库，可直接使用这个加载器，
如果程序没有自定义自己的类加载器，一般情况下这个就是程序中默认的加载器。
自定义类加载器（User ClassLoader），从JVM的角度来说，可以分为启动类加载器和其他类加载器，之所以这样划
分，是因为启动类加载器是C++语言实现的，是虚拟机的一部分，而其他所有的类加载器，都是Java语言实现的，
独立于虚拟机外部，并且全部都继承子抽象类java.lang.ClassLoader。从Java开发者的角度来说，可以分为上面
这四种类加载器。

    类加载器可以说是Java语言的一个创新，也是Java语言流程的重要原因之一，它最初是为了满足Java Applet的需求
而开发出来的。虽然Applet这个产品，现在已经很少有人用了，但是类加载器这项技术却被广泛应用于当前的项目中。例如：
    * 类层次的划分；
    * OSGI；
    * 热部署；
    * 代码加密；

    关于类加载器，我们至少要清楚一个问题：如果判断2个类相等？比较2个类是否相等，只有在这2个类都是由同一个类加载器
加载的前提下，才有意义。否则，即使2个类来源于同一个Class文件，被同一个虚拟机加载，只要加载它们的类加载器不同，那么
这2个类，就不相等。

package com.yangcq.jvm;
import java.io.IOException;
import java.io.InputStream;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description 如何判断2个类是否相等：
 * @ 比较2个类是否相等，只有在这2个类都是由同一个类加载器加载的前提下，才有意义。
 *
 */
public class ClassIsEqualTest {
	final static Log log = LogFactory.getLog(ClassIsEqualTest.class);
	public static void main(String[] args) {
		// 自定义类加载器 myClassLoader
		ClassLoader myClassLoader = new ClassLoader(){
			@Override
			public Class<?> loadClass(String name) throws ClassNotFoundException{
				try{
					String fileName = name.substring(name.lastIndexOf(".") + 1) + ".class";
					InputStream inputStream = getClass().getResourceAsStream(fileName);
					if(inputStream == null){
						return super.loadClass(name);
					}
					byte[] b = new byte[inputStream.available()];
					inputStream.read(b);
					return defineClass(name,b,0,b.length);
				}
				catch(IOException e){
					throw new ClassNotFoundException(name);
				}
			}
		};
		
		try {
			// 使用自定义的类加载器，加载com.yangcq.jvm.ClinitAndStaticTest_2
			Object obj = myClassLoader.loadClass("com.yangcq.jvm.ClinitAndStaticTest_2").newInstance();
			// 测试输出
			log.info("用自定义加载器myClassLoader加载Java的Object类，obj.getClass() = " + obj.getClass());
			log.info("加载器是： " + obj.getClass().getClassLoader());
			
			// 使用默认的加载器 AppClassLoader 加载com.yangcq.jvm.ClinitAndStaticTest_2
			log.info("类： " + ClinitAndStaticTest_2.class);
			log.info("加载器是： " + ClinitAndStaticTest_2.class.getClassLoader());
			
			if(obj instanceof com.yangcq.jvm.ClinitAndStaticTest_2){
				log.info("2个类相等");
			}
			else{
				log.info("2个类不相等");
			}
		} 
		catch (InstantiationException e) {
			e.printStackTrace();
		} 
		catch (IllegalAccessException e) {
			e.printStackTrace();
		} 
		catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}

控制台输出：

2016-8-12 20:57:18 com.yangcq.jvm.ClassIsEqualTest main
信息: 用自定义加载器myClassLoader加载Java的Object类，obj.getClass() = class com.yangcq.jvm.ClinitAndStaticTest_2
2016-8-12 20:57:18 com.yangcq.jvm.ClassIsEqualTest main
信息: 加载器是： com.yangcq.jvm.ClassIsEqualTest$1@8813f2
2016-8-12 20:57:18 com.yangcq.jvm.ClassIsEqualTest main
信息: 类： class com.yangcq.jvm.ClinitAndStaticTest_2
2016-8-12 20:57:18 com.yangcq.jvm.ClassIsEqualTest main
信息: 加载器是： sun.misc.Launcher$AppClassLoader@addbf1
2016-8-12 20:57:18 com.yangcq.jvm.ClassIsEqualTest main
信息: 2个类不相等

五，类加载的步骤

1，加载：查找并加载类的二进制数据
在加载阶段，JVM需要完成以下三个流程：
    * 通过一个类的全限定名来获取定义此类的二进制字节流；
    * 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
    * 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口；
JVM规范对于从哪里获取字节流文件，并没有要求，目前主要有以下几个途径：
    * 从ZIP包中读取，这个很常见，例如我们经常使用的WAR包或者JAR包；
    * 从网络中获取，这个场景的典型应用是Applet；
    * 运行时计算生成，这种场景使用最多的就是动态代理技术，在java.lang.reflect.Proxy中，就是用了
ProxyGenerator.generateProxyClass来为特定接口生成形式为“*$Proxy”的代理类的二进制字节流。
    * 由其他文件生成，典型场景是JSP应用，即由JSP文件生成对应Class类。
    * 从数据库中读取，这种场景相对少见些。

    这里有一种特殊情况：数组类的加载。数组类本身不通过类加载器创建，它是由JVM直接创建的。但是数组类的
元素类型，也就是数组去掉所有维度的类型，最终是类加载器来加载的。
    
2，验证：确保被加载类的正确性
验证是连接阶段的第一步，这一阶段的目的是为了确保Class文件的字节流中包含的信息符合当前JVM的要求，并且
不会危害虚拟机的安全。
从整体上来看，验证分为4个阶段：文件格式验证、元数据验证、字节码验证、符号引用验证。

3，准备：为类的静态变量分配内存，并将其初始化为默认值
准备阶段正式为类变量，也就是全局变量分配内存并设置初始值，这些变量所使用的内存都将在方法区中进行分配。
需要强调的是，这个时候进行内存分配的只有类变量，也就是被static关键字修饰的变量，不包括实例变量，实例
变量会在对象初始化时随着对象一起分配在Java堆中。

4，解析：把类的符号引用转化为直接引用
解析阶段，是JVM将常量池中的符号引用替换为直接引用的过程。JVM规范并没有规定解析阶段发生的具体时间，只是
规定了，在执行下面16个字节码指令之前，需要先对他们所使用的符号引用进行解析：
    * anewarray
    * checkcast
    * getfield
    * getstatic
    * instanceof
    * invokedynamic
    * invokespecial
    * invokestatic
    * invokevirtual
    * ldc
    * ldc_w
    * multianewarray
    * new
    * putfield
    * putstatic
因此，在具体实现时，JVM可以根据自己的需要来判断到底是在类被加载器加载时就对常量池中的符号引用进行解析，
还是等到一个符号引用将要被使用时再去进行解析。
解析阶段，主要针对以下集中类型：
    * 类
    * 接口
    * 字段
    * 类方法
    * 接口方法
    * 方法类型
    * 方法句柄
    * 调用点限定符
这些符号引用分别对应常量池的下面这些常量类型：
    * CONSTANT_Class_info
    * CONSTANT_Class_info
    * CONSTANT_Fieldref_info
    * CONSTANT_Methodref_info
    * CONSTANT_InterfaceMethodref_info
    * CONSTANT_MethodType_info
    * CONSTANT_MethodHandle_info
    * CONSTANT_InvokeDynamic_info

5，初始化：为类的静态变量赋予正确的初始值
类的初始化，是类加载过程的最后一步，到了初始化阶段，才真正开始执行类中定义的Java程序代码（或者说是字节码）。在变量阶段，
变量已经赋过一次系统要求的初始值，而在初始化阶段，则根据程序员程序制定的主观计划去初始化类变量和其他资源，或者可以从另外
一个角度来表达：初始化阶段是执行类构造器<clinit>()方法的过程。在这里，我们先看一下<clinit>()方法执行过程中一些可能会影
响程序运行行为的特点和细节：
    * <clinit>()方法是由编译器自动收集类中的所有的类变量的赋值动作和静态代码块中的语句合并产生的。编译器收集的顺序是由
语句在源文件中的顺序决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句可以赋值，
但是不能访问。

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description JVM类的初始化：
 * @ 静态语句块中只能访问到定义在静态语句块之前的变量。
 * @ 定义在它之后的变量，在前面的静态语句可以赋值，但是不能访问。
 *
 */
public class ClinitAndStaticTest_1 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	// 静态代码块
	static{
		i = 101;    // 可以赋值
		System.out.println("i = " + i);  // 不能引用，也就是不能访问
		// 编译器报错信息：Cannot reference a field before it is defined 
		// 也就是我们经常说的：非法向前引用。
	}
	
	static int i = 100;     // 在静态代码块之后定义的静态变量i
	
	public static void main(String[] args) {
		log.info("i = " + i);
	}
}

    * <clinit>()方法与类的构造函数（或者说实例构造器<init>()方法）不同，它不需要显示的调用父类的构造器，JVM会保证在子类
的<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕。因此在虚拟机中，第一个被执行的<clinit>()方法是java.lang.Object

    * 由于父类的<clinit>()方法先执行，也就意味着，父类中定义的静态语句块要优先于之类的变量赋值操作。通过下面一段程序进行演示

package com.yangcq.jvm;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
/**
 * 
 * @author yangcq
 * @description JVM类的初始化：
 * @ 由于父类的<clinit>()方法先执行，也就意味着，父类中定义的静态语句块要优先于之类的变量赋值操作
 *
 */
public class ClinitAndStaticTest_2 {
	final static Log log = LogFactory.getLog(StaticTest_Main.class);
	public static void main(String[] args) {
		log.info("SubClass.str1 = " + SubClass.str1);
	}

	// 父类
	static class SuperClass{
		public static String str = "yangcq20160812";
		static{
			str = "yangcq20160813";
			log.info("父类中的静态代码块执行了...");
		}
	}
	
	// 子类
	static class SubClass extends SuperClass{
		public static String str1 = str;  // 把父类中的str的值，赋给str1
		static{
			log.info("子类中的静态代码块执行了...");
		}
	}
	
	/**
	 * 控制台输出
	 * 
     * 2016-8-12 20:26:48 com.yangcq.jvm.ClinitAndStaticTest_2$SuperClass <clinit>
     * 信息: 父类中的静态代码块执行了...
     * 2016-8-12 20:26:48 com.yangcq.jvm.ClinitAndStaticTest_2$SubClass <clinit>
     * 信息: 子类中的静态代码块执行了...
     * 2016-8-12 20:26:48 com.yangcq.jvm.ClinitAndStaticTest_2 main
     * 信息: SubClass.str1 = yangcq20160813
     * 
	 */
}

    * <clinit>()方法对于接口和类来说并不是必须的，如果一个类中没有静态语句块，也就是没有对变量进行赋值操作，那么编译器可以
不为这个类生成<clinit>()方法。
    * 接口中不能使用静态语句块，但仍然可以有变量初始化的赋值操作，因此接口与类一样都是会生成<clinit>()方法。但接口与类不同的
是，执行接口的<clinit>()方法不需要先执行父接口的<clinit>()方法，只有当父接口中定义的变量使用时，父接口才会初始化。另外，接口
的实现类在初始化时也一样不会执行接口的<clinit>()方法。

    * JVM会保证一个类的<clinit>()方法在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只有一个线程去执
行这个类的<clinit>()方法，其他线程都需要阻塞等待，知道活动线程执行<clinit>()方法完毕。如果一个类的<clinit>()方法中有耗时很
长的操作，就可能造成多个进程阻塞，在实际应用中，这种阻塞往往是很隐蔽的。

六，双亲委派模型

双亲委派模型的工作流程：当一个类加载器收到一个类加载的请求时，它首先不会自己去尝试加载这个类，而是把这
个请求委派给父类加载器去完成，每一层的类加载器都是如此，因此所有的类加载请求最终都是会传递到顶层的启动
类加载器中，只有当父类加载器反馈自己无法完成这个加载请求时，子加载器才会尝试自己去加载。
双亲委派模型具有以下特性：
    使类的加载器之间，具有优先级关系；
    对于保证Java程序的稳定性运作很重要；