虚拟机类加载机制

代码编译的结果：本地机器码 转变为 字节码

一、概述

1.1 虚拟机的类加载机制

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

1.2 Java语言的动态加载和动态连接

  java语言中类型的加载连接以及初始化过程都是在程序运行期间完成的，这种策略虽然会使类加载时稍微增加一些性能开销，但是会为java应用程序提供高度的灵活性。java里天生就可以动态扩展语言特性就是依赖运行期间动态加载和动态连接这个特点实现的。比如，如果编写一个面向接口的程序，可以等到运行时再指定其具体实现类。
  用户可以通过Java预定义的和自定义类加载器，让一个本地的应用程序可以在运行时从网络或其他地方加载一个二进制流作为程序代码的一部分，这种组装应用程序的方式目前已广泛应用于Java程序之中。

1.3 两个语言上的约定

1. 在实际情况中，每个Class文件都有可能代表着Java语言中的一个类或接口，后文中直接对“类”的描述都包含了类和接口的可能性，而对于类和接口需要分开描述的场景会特别指明。
2. 与前面介绍Class文件格式时的约定一致，本章所提到的“Class文件”并非特指某个存在于具体磁盘中的文件，而是一串二进制的字节流，无论以何种形式存在都可以。

二、类加载的时机

  类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载（Loading）、验证（Verification）、准备（Preparation）、解析（Resolution）、初始化（Initialization）、使用（Using）和卸载（Unloading）7个阶段。其中验证、准备、解析3个部分统称为连接（Linking），这7个阶段的发生顺序如图：

  加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班地开始，而解析阶段则不一定：它在某些情况下可以在初始化阶段之后再开始，这是为了支持Java语言的运行时绑定（也称为动态绑定或晚期绑定）。

2.1 主动引用

  什么情况下需要开始类加载过程的第一个阶段：加载？Java虚拟机规范中并没有进行强制约束，这点可以交给虚拟机的具体实现来自由把握。但是对于初始化阶段，虚拟机规范则是严格规定了有且只有5种情况必须立即对类进行“初始化”（而加载、验证、准备自然需要在此之前开始）：

1）遇到new、getstatic、putstatic或invokestatic这4条字节码指令时，如果类没有进行过初始化，则需要先触发其初始化。生成这4条指令的最常见的Java代码场景是：

• 使用new关键字实例化对象的时候
• 读取或设置一个类的静态字段（被final修饰、已在编译期把结果放入常量池的静态字段除外）的时候
• 以及调用一个类的静态方法的时候

2）使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化。

3）当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要先触发其父类的初始化。

4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main（）方法的那个类），虚拟机会先初始化这个主类。

5）当使用JDK 1.7的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

  对于这5种会触发类进行初始化的场景，虚拟机规范中使用了一个很强烈的限定语：“有且只有”，这5种场景中的行动称为对一个类进行主动引用。

2.2 被动引用

  除以上主动引用外，所有引用类的的方式都不会触发初始化，称为被动引用。

例1

通过子类引用父类静态字段，不会导致子类初始化；

public class SuperClass 
{
    static 
    {
        System.out.println("SuperClass init！");
    }
    public static int value = 123;
}


public class Subclass extends SuperClass 
{
    static 
    {
        System.out.println("Subclass init!");
    }
}

public class NotInitialization 
{
	public static void main(String[] args) 
	{
		System.out.println(SubClass.value);
	}
}

输出：“SuperClass init！”

例2

通过数组定义引用类，不会触发此类的初始化

public class NotInitialization 
{
	public static void main(String[] args) 
	{
		SuperClass[] sca = new SuperClass[10];
		//通过new 创建对象,可以实现类初始化
        //SuperClass superClass = new SuperClass();
	}
}

结果：运行后发现没有输出“SuperClass init！”

  Java语言中对数据的访问比 C/C++ 相对安全是因为这个类封装了数组元素的访问方法，而 C/C++直接翻译为对数组指针的移动。

例3

常量在编译阶段会存入调用类的常量池中，本质上并没有直接引用定义常量的类，因此不会触发定义常量的类的初始化

public class ConstClass 
{
	static 
	{
		System.out.println("ConstClass init!");
	}
	public static final String HELLOWORLD = "hello world";
}

public class NotInitialization 
{
	public static void main(String[] args) 
	{
		System.out.println(ConstClass.HELLOWORLD);
	}
}

结果：运行后发现没有输出“ConstClass init！”，这是因为虽然在Java源码中引用了ConstClass类中的常量HELLOWORLD，但其实在编译阶段通过常量传播优化，已经将此常量的值“hello world”存储到了NotInitialization类的常量池中，以后NotInitialization对常量ConstClass.HELLOWORLD的引用实际都被转化为NotInitialization类对自身常量池的引用。

2.3 接口初始化区别

  上面的代码都是用静态语句块“static{ }”来输出初始化信息的，而接口中不能使用“static{ }”语句块，但编译器仍然会为接口生成“< clinit >( )”类构造器，用于初始化接口中定义的成员变量。

  当一个类在初始化时，要求其父类全部都已经初始化过了。对于接口，当一个接口在初始化时，并不要求其父接口全部都完成了初始化，只有在真正使用到父接口时（如引用父接口中定义的常量）才会初始化。

三、类加载的过程

  下面我们详细的说一下java虚拟机中类加载的全过程：加载、验证、准备、解析和初始化这5个阶段锁执行的具体工作。

3.1 加载

在加载阶段，虚拟机需要完成以下3件事情：
通

• 过一个类的全限定名来获取定义此类的二进制字节流。
• 将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构。
• 在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

① 通过类型的完全限定名，产生一个代表该类型的二进制数据流的几种常见形式：

• 从zip包中读取，成为日后JAR、EAR、WAR格式的基础；
• 从网络中获取，这种场景最典型的应用就是Applet;
• 运行时计算生成，这种场景最常用的就是动态代理技术了；
• 由其他文件生成，比如我们的JSP；
• 从数据库中读取，比如有些中间件服务器

注意： 非数组类加载阶段既可以使用系统提供的类加载器来完成，也可以由用户自定义的类加载器去完成。（即重写一个类加载器的loadClass（）方法）
  对于数组类而言，情况就有所不同，数组类本身不通过类加载器加载，它是由Java虚拟机直接创建的。但数组类与类加载器仍然有很密切的关系，因为数组类的元素类型（Element Type，指的是数组去掉所有维度的类型）最终是要靠类加载器去创建。

② 数组类创建过程规则

• 如果数组的组件类型（Component
  Type,，指的是数组去掉一个维度的类型）是引用类型，就递归采用上面的加载过程加载这个组件类型，数组将在加载该组件类型的类加载器的类名称空间上被标识。（类必须和类加载器一同确定唯一性）
• 如果不是引用类型（例 int[]），Java虚拟机将会把数组标记为与引导类加载器关联
• 数组类的可见性与组件类型可见性一致，如果不是引用类型，就是public

  加载完成之后，虚拟机外部的二进制字节流就按照虚拟机的格式存储在方法区之中，方法区中的数据存储格式由虚拟机实现自行定义，虚拟机规范未规定此区域的具体数据结构。然后在内存中实例化一个java.lang.Class类的对象。对于HotSpot而言，这个对象放在方法区中，而不是堆中。

  加载过程和连接过程是交叉的，比如验证，连接阶段可能已经开始。

3.2 验证

目的：确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。

  验证阶段很重要，是否严谨，直接决定了虚拟机是否能承受恶意代码攻击，执行角度来看，这个阶段占用了相当大的一部分。

  虚拟机规范对这个阶段的限制比较笼统，列举了一些Class文件格式中的静态和结构化约束，如果验证到输入的字节流不符合格式的约束，会抛出一个java.lang.VerifyError异常或其子类异常。到了Java虚拟机规范 SE 7版，才做了大量的验证阶段要求。总体分为四个阶段的验证：

3.2.1 文件格式验证

  验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。该阶段验证点包括：

• 是否以魔数0xCAFEBABE开头

• 主、次版本号是否在当前虚拟机处理范围之内

• 常量池的常量中是否有不被支持的常量类型（检查常量tag标志）

• 指向常量的各种索引值中是否有指向不存在的常量或不符合类型的常量

• CONSTANT_Utf8_info型的常量中是否有不符合UTF8编码的数据

• Class文件中各个部分及文件本身是否有被删除的或附加的其他信息。
  …

  该验证阶段的主要目的是保证输入的字节流能正确地解析并存储于方法区之内。这个阶段验证是基于二进制字节流进行的，只有通过这个阶段的验证后，字节流才会进入内存的方法区进行存储，所以后面的3个阶段的全部是基于方法区的存储结构进行的，不会再直接操作字节流。

3.2.2 元数据验证

  第二阶段是对字节码描述的信息进行语义分析，以保证其描述的信息符合Java语言规范的要求，该阶段验证点包括：

• 这个类是否有父类（除了java.lang.Object 之外，所有的类都应当有父类）

• 这个类的父类是否继承了不允许被继承的类（final 修饰的类）

• 如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法

• 类中的字段、方法是否与父类产生矛盾（例如覆盖了父类的final 字段，或者出现不符合规则的方法重载，例如方法参数都一致，但返回值类型缺不同等）
  …

  这个阶段目的就是对类的元数据进行语义校验，保证不存在不符合Java语言规范的元数据信息。

3.2.3 字节码验证

  第三阶段是整个验证过程中最复杂的一个阶段。主要目的是通过数据流和控制流分析，确定程序语义是合法的、符合逻辑的。在第二阶段对元数据信息中的数据类型做完检验后，这个阶段将对类的方法体进行检验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事件，例如：

• 保证任意时刻操作数栈的数据类型和指令代码序列都能配合工作，例如不会出现类似这样的情况：在操作数栈放置了一个int类型的数据，使用时却按long类型来加载入本地变量表中。
• 保证跳转指令不会跳转到方法体以外的字节码指令上
• 保证类型转换是有效的，例如子类对象赋给父类变量是安全的，但是把父类对象赋值给子类数据类型，甚至把对象赋值给与它毫无继承关系，完全不相干的一个数据类型，则是危险和不合法的。

…

这个阶段不能保证完全正确，可能会有问题。

3.2.4 符号引用验证

  最后一个阶段的校验发生在虚拟机将符号引用转化为直接引用的时候，这个转化将在第三阶段——解析中发生。符号引用验证是对类自身以外（常量池中的各种符号引用）的信息进行匹配校验，主要校验

• 符号引用中通过字符串描述的全限定名是否能找到对应的类
• 在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段
• 符号引用中的类、字段、方法的访问性（private、protect、public、default）是否可被当前类访问

  符号引用验证的目的是确保解析动作能正常执行，如果无法通过验证，会抛出java.lang.IncompatibleClassChangeError异常的子类，如java.lang.IllegalAccessError、java.lang.NoSuchFieldError和java.lang.NoSuchMethodError等。

  验证阶段很重要，但是如果保证代码是正常的，可以关闭这个阶段缩短类加载时间，通过参数-Xverify:none来关闭。

3.3 准备

  准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。（备注：这时候进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量，实例变量将会在对象实例化时随着对象一起分配在Java堆中）。

① 初始值通常是数据类型的零值：

对于：

public static int value = 123;

变量value在准备阶段过后的初始值为0而不是123，因为这时候尚未开始执行任何java方法，把value赋值为123的putstatic指令是程序被编译后，存放于类构造器< clinit >() 方法之中，所以把value赋值为123的动作将在初始化阶段才会被执行。

② 特殊情况：

对于：

public static final int value = 123;

编译时Javac将会为value生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将value赋值为123。

③ 基本数据类型的零值：

数据类型	零值
int	0
long	0L
short	（short）0
char	‘\u0000’
byte	(byte) 0
boolean	false
float	0.0f
double	0.0d
reference	null

3.4 解析

解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。

• 符号引用(Symbolic References)：

  符号引用以一组符号来描述所引用的目标，符号可以是符合约定的任何形式的字面量，符号引用与虚拟机实现的内存布局无关，引用的目标并不一定已经加载到内存中。

• 直接引用（Direct References）:

  直接引用可以是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。直接引用与虚拟机实现的内存布局相关，引用的目标必定已经在内存中存在。

  虚拟机规范没有规定解析阶段发生的具体时间，只要求了在执行了anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invokestatic、invokevirtual、ldc、ldc_w、multianewarray、new、putfield、putstatic 这16个用于操作符号引用的字节码指令之前，先对它们所使用的符号引用进行解析。所以虚拟机实现可以根据需要来判断到底是在类被加载时解析还是等到一个符号引用将要被使用前才去解析。

  对一个符号引用进行多次解析请求是很常见的，为了避免这个问题，虚拟机实现可以在第一个解析成功后，缓存结果，后续使用这个结果即可。但是如果第一次失败，后面都会失败。

  上述避免重复解析的规则，对于指令invokedynamic指令不成立。因为这个本来就是用来支持动态语言的，其对应的引用称为“动态调用点限定符"。动态的含义就是必须等到程序实际运行到这条指令的时候，解析动作才能进行。

  解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。分别对应编译后常量池内
　　CONSTANT_Class_Info
　　CONSTANT_Fieldref_Info
　　CONSTANT_Methodref_Info
　　CONSTANT_InterfaceMethodref_Info
　　CONSTANT_MethodType_Info
　　CONSTANT_MethodHandle_Info
　　CONSTANT_Invokeddynamic_Info
7种常量类型。Java是静态类型语言，后面3种与JDK7种新增的动态语言支持相关，本章不进行介绍，留到动态语言调用，即虚拟机执行引擎的时候描述。

3.4.1 类或接口的解析

  如果当前代码所处的类为D，将一个未解析过的符号引用N解析成一个类或接口C的直接引用，那么需要完成下面步骤：

1. 如果C不是数组类型，虚拟机会将N的全限定名传递给D的类加载器，去加载类C，加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，一旦失败解析失败。
2. 如果C是数组，并且数组的元素类型为对象，N的描述符会是类似 [Ljava/lang/Integer 形式，那将会按1的规则加载数组的元素类型，接着由虚拟机生成一个代表此数组维度和元素的数组对象。这里就是加载Integer类了。
3. 上述步骤成功，在虚拟机中已经有一个有效的C类或接口了，但是还需要对符号引用进行验证，确定D是否具备对C的访问权限，不具备将抛出 java.lang.IllegalAccessError异常。

  通俗的说就是Test类有个X tmp对象。类型X没有被解析，是一个符号引用，如果不是一个数组，就要用Test的类加载器加载这个类，如果是数组，也要加载，不过要额外开辟数组对象。

3.4.2 字段解析

  要解析一个未被解析过的字段符号引用，首先会对字段表内class_index项中索引的CONSTANT_Class_Info 符号引用进行解析，也就是字段所属的类或接口的符号引用。如果在解析这个类或接口符号引用过程中出任何异常，都会导致字段符号引用解析失败。解析成功，需要进行下面操作，假设字段所属类或接口是C：

1. 如果C本身包含了简单名称和字段描述符都与目标相匹配的字段，则直接返回这个字段的直接引用，查找结束。
2. 否则，C中实现了接口，从下往上递归搜索接口，如果包含简单名称和字段描述符与目标匹配，返回直接引用，查找结束
3. 如果还没找到，会从下到上搜索继承体系，如果匹配返回直接引用，查找结束
4. 否则，失败，抛出java.lang.NoSuchFieldError异常。

  成功后也会进行验证，判断有没有访问权限。若不具备对字段的访问权限，将抛出 java.lang.IllegalAccessError 异常。

  通俗的说就是：类Test打印了C.value这个字段，C中没有，先从下往上的接口中查找，仍没有，从下往上的继承找，还是没找到就抛出异常。

  实际上编译器会更严格一些，如果一个字段同时出现在C的接口和父类中，或者同时在自己或父类的多个接口中出现，编译器可能拒绝编译。

3.4.3 类方法解析

  方法解析和字段解析第一步都一样，先对所属的类或接口的符号引用进行解析，成功后会对后续的类方法进行搜索：

1. 类方法和接口方法的符号引用的常量类型定义是分开的，如果在类方法表中发现class_index中索引的C是个接口，直接抛出java.lang.IncompatibleClassChangeError异常
2. 在类中查找是否有简单名称和描述符都匹配的方法，找到就返回这个方法的直接引用，查找结束
3. 否则，去该类的父类查找，直到找到
4. 没找到，去该类实现的接口列表及它们的父接口之中递归查找，找到了说明C是一个抽象类，抛出
   java.lang.AbstractMethodError异常
5. 否则,宣告方法查找失败，抛出java.lang.NoSuchMethodError

  成功后返回直接引用，也会进行验证，判断有没有访问权限。若不具备对此方法的访问权限，将抛出 java.lang.IllegalAccessError 异常。
　　  简单说就是D中调用一个C.doSomething()方法，先找这个引用是不是一个接口，不是就要找这个方法是哪个父类的，没找到那就是接口的了，没有具体实现，要抛出异常，都没找到更错的离谱了。

3.4.4 接口方法解析

  接口方法也需要先解析出接口方法表的方法所属的类或接口的符号引用，解析成功，用C表示这个接口，进行下面的步骤：

1. 如果C是个类，不是接口，抛出java.lang.IncompatibleClassChangeError异常
2. 是接口，查找C中是否有匹配的，有就查找结束
3. 没找到，就在C的父接口递归查找，直到Object类，匹配就结束
4. 找不到，抛出java.lang.NoSuchMethodError异常
5. 接口的方法默认是public，所以没有访问权限的问题。

  接简单说就是Test调用C.doSomething()，这是一个接口方法，如果C是类那么抛出异常，如果C中没有这个方法，找父接口，没找到也要抛出异常。

3.5 初始化

  初始化是类加载的最后一步，会真正执行类中定义的Java代码（或者说是字节码）。准备阶段，变量赋予了零值，初始化阶段要赋予真正的值了。

  初始化是执行类构造器< clinit >()方法的过程

< clinit >()方法是由编译器自动收集类中的所有类变量的赋值动作和静态语句块(static{ }块)中的语句合并产生的，编译器收集的顺序是由语句在源文件中出现的顺序所决定的，静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在前面的静态语句快可以赋值，但是不能访问。

public class Test 
{
    static 
    {
        i = 0;  //  给变量复制可以正常编译通过
        System.out.print(i);  // 这句编译器会提示“非法向前引用”  
    }
    static int i = 1;
}

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

由于父类的< clinit >()方法先执行，也就意味着父类中定义的静态语句快要优先于子类的变量赋值操作。如在以下代码清单中，字段B的值将会是2而不是1。

static class Parent {
		public static int A = 1;
		static {
			A = 2;
		}
}

static class Sub extends Parent {
		public static int B = A;
}

public static void main(String[] args) {
		System.out.println(Sub.B);
}

< clinit >()方法对于类或接口来说并不是必须的，如果一个类中没有静态语句，也没有变量赋值的操作，那么编译器可以不为这个类生成< clinit >()方法。

接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样都会生成< clinit > ()方法。但接口与类不同的是，执行接口的< clinit >()方法不需要先执行父接口的< clinit >()方法。只有当父接口中定义的变量被使用时，父接口才会被初始化。另外，接口的实现类在初始化时也一样不会执行接口的< clinit >()方法。

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

四、类加载器

  虚拟机设计团队把类加载阶段中的“通过一个类的全限定名来获取描述此类的二进制字节流”这个动作放到Java虚拟机外部去实现，以便让应用程序自己决定如何去获取所需要的类。实现这个动作的代码模块称为“类加载器”。

4.1 类与类加载器

  对于任何一个类，都需要由加载它的类加载器和这个类来确立其在JVM中的唯一性，每一个类加载器，都拥有一个独立的类名称空间。也就是说，两个类来源于同一个Class文件，并且被同一个类加载器加载，这两个类才相等。

4.2 双亲委派模型

  从虚拟机的角度来说，只存在两种不同的类加载器：一种是启动类加载器（Bootstrap ClassLoader），该类加载器使用C++语言实现，属于虚拟机自身的一部分。另外一种就是所有其它的类加载器，这些类加载器是由Java语言实现，独立于JVM外部，并且全部继承自抽象类java.lang.ClassLoader。

  从Java开发人员的角度来看，大部分Java程序一般会使用到以下三种系统提供的类加载器：

4.2.1 启动类加载器（Bootstrap ClassLoader）

  负责加载< JAVA_HOME >\lib目录中并且能被虚拟机识别的（仅按照文件名识别，如rt.jar，名字不符合的类库即使放在lib目录中也不会被加载）类库到JVM内存中。该类加载器无法被Java程序直接引用。

4.2.2 扩展类加载器（Extension ClassLoader）

  该加载器主要是负责加载< JAVA_HOME >\lib\ext目录中的所有类库，该加载器可以被开发者直接使用。

4.2.3 应用程序类加载器（Application ClassLoader）

  该类加载器也称为系统类加载器，它负责加载用户类路径（Classpath）上所指定的类库，开发者可以直接使用该类加载器，如果应用程序中没有自定义过自己的类加载器，一般情况下这个就是程序中默认的类加载器。

  我们的应用程序都是由这三类加载器互相配合进行加载的。另外还有自定义类加载器(必须继承 ClassLoader)。

这些类加载器之间的关系如下图所示：

  如上图所示的类加载器之间的这种层次关系，就称为类加载器的双亲委派模型（Parent Delegation Model）。该模型要求除了顶层的启动类加载器外，其余的类加载器都应当有自己的父类加载器。子类加载器和父类加载器不是以继承（Inheritance）的关系来实现，而是通过组合（Composition）关系来复用父加载器的代码。

4.3 双亲委派模型的工作过程

  如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器去完成，每一个层次的加载器都是如此，因此所有的类加载请求都会传给顶层的启动类加载器，只有当父加载器反馈自己无法完成该加载请求（该加载器的搜索范围中没有找到对应的类）时，子加载器才会尝试自己去加载。

4.4 双亲委派模型的好处

  Java类随着它的类加载器一起具备了一种带有优先级的层次关系。例如java.lang.Object类，无论哪个类加载器去加载该类，最终都是由启动类加载器进行加载，因此Object类在程序的各种类加载器环境中都是同一个类。否则的话，如果不使用该模型的话，如果用户自定义一个java.lang.Object类且存放在classpath中，那么系统中将会出现多个Object类，应用程序也会变得很混乱。如果我们自定义一个rt.jar中已有类的同名Java类，会发现JVM可以正常编译，但该类永远无法被加载运行。

4.5 双亲委派模型的实现

  实现双亲委派的代码都集中在java.lang.ClassLoader的loadClass（）方法之中，如下代码所示，逻辑清晰易懂：先检查是否已经被加载过，若没有加载则调用父加载器的loadClass（）方法，若父加载器为空则默认使用启动类加载器作为父加载器。如果父类加载失败，抛出ClassNotFoundException异常后，再调用自己的findClass（）方法进行加载。

protected synchronized Class＜?＞loadClass（String name,boolean resolve）throws ClassNotFoundException
{
	//首先，检查请求的类是否已经被加载过了
	Class c=findLoadedClass（name）；
	if（c==null）
	{
		try{
			if（parent！=null）
			{
				c=parent.loadClass（name,false）；
			}
			else
			{
				c=findBootstrapClassOrNull（name）；
			}
		}catch（ClassNotFoundException e）{
			//如果父类加载器抛出ClassNotFoundException
			//说明父类加载器无法完成加载请求
		}
		if（c==null）
		{
			//在父类加载器无法加载的时候
			//再调用本身的findClass方法来进行类加载
			c=findClass（name）；
		}
	}
	if（resolve）
	{
		resolveClass（c）；
	}
	return c；
}

4.6 破坏双亲委派模型

双亲委派模型不是一个强制性的约束模型，有被破坏的情况。

4.6.1 第一次“被破坏”

  第一次是因为兼容老版本的JDK，这个模型在1.2版本才出现，但是ClassLoader在1.0就存在了。为了向前兼容，添加了一个protected方法findClass()。
　　在此之前，用户去继承java.lang.ClassLoader 的唯一目的就是重写loadClass（）方法，因为虚拟机在进行类加载的时候会调用加载器的私有方法loadClassInternal（），而这个方法的唯一逻辑就是去调用自己的loadClass()。
　　1.2之后就不提倡重写loadClass了，而是写findClass方法，因为loadClass的基本逻辑已经写好，父类加载失败，就会调用自己的findClass进行加载，这样保证新写出来的类加载器是符合双亲委派模型的。

4.6.2 第二次“被破坏”

  第二次破坏是因为双亲委派模型自身的缺陷，作为顶层的类通常是被底层类调用的，但是如果顶层的基本类调用了底层的用户类就麻烦大了。顶层的类加载器并不认识用户的类，这样如何去加载这个类呢？
　　典型的例子就是JNDI服务，其目的是对资源进行集中管理和查找，需要调用应用程序的classpath的代码，比如SPI服务。
　　为了解决这个问题，设计了一个线程上下文类加载器（Thread Context ClassLoader）。这个类加载器可以通过java.lang.Thread类的setContextClassLoader方法进行设置，如果创建线程的时候没有设置，将会从父线程中继承一个，全局范围都没有设置，默认就是应用程序类加载器。
　　设置了这个，就可以在父类加载器中获取子类加载器，让其进行加载类了。这是无奈之举，很多SPI加载动作都采用了这种方式，比如：JNDI、JDBC、JCE、JAXB、JBI等。

4.6.3 第三次“被破坏”

  第三次被破坏是由于追求动态性导致的。比如：代码热替换（HotSwap），模块热部署（Hot Deployment）等，说白了就是希望应用程序能像我们的计算机外设那样，接上鼠标、U盘，不用重启机器就能立即使用，鼠标有问题或要升级就换个鼠标，不用停机也不用重启。
　　比较出名的就是OSGi这个“事实上”的Java模块化标准，其模块热部署的关键就是它自定义的类加载器实现机制。每个模块（Bundler）都有一个自己的类加载器，当需要更换一个Bundle时，把Bundle连同类加载器一起换掉以实现代码热替换。
　　在OSGi环境下，类加载器不再是双亲委派模式中的树形结构，而是进一步发展为更加复杂的网状结构。

当收到类加载请求时，OSGi按照下面的顺序进行类搜索：

1. java.*开头的类委派给父类加载器加载
2. 将委派列表中的类交给父类加载器加载
3. 将import列表中的类委派给Export这个类的Bundle的类加载器加载
4. 查找当前Bundle的Classpath，使用自己的类加载器加载
5. 查找类是否在自己的Fragment Bundle中，如果在，委派给Fragment Bundle进行加载
6. 查找Dynamic Import列表的Bundle，委派给对应Bundle加载
7. 类查找失败