Java类加载机制

1.类的生命周期
加载（loading）——验证（verification）——准备（preparation）——解析（resolution）——初始化（initialization）——使用（using）——卸载（unloading）
验证、准备、解析 三个阶段统称为 连接（linking）
1.1. 只有5种情况必须立即对类进行“初始化“：
（1）遇到new、getstatic、putstatic、invokestatic四条字节码指令时，如果类没有进行初始化，则需触发其初始化。
生成这4条指令的常见的Java代码场景是：
使用new关键字实例化对象；
读取或设置一个类的静态字段（被final修饰，已在编译期把结果放入常量池的静态字段除外）；
调用一个类的静态方法。
（2）使用java.lang.reflect包的方法对类进行反射调用时，如果类没有进行初始化，则需触发其初始化
（3）当初始化一个类时，如果发现其父类还没有进行初始化，则需先触发其父类的初始化
（4）当虚拟机启动时，用户需要指定一个要执行的主类（包含main（）方法的那个类），虚拟机会先初始化这个主类
（5）当使用动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic,REF_putStatic,REF_invokeStatic的方法句柄，并这个方法句柄所对应的类没有进行初始化，则需先触发其初始化
eg:

/**
*   被动使用类字段演示一
*   通过子类引用父类的静态字段，不会导致子类初始化
**/
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
    123
注：对于静态字段，只有直接定义这个字段的类才会被初始化，因此通过其子类来引用父类中定义的静态字段，只会触发父类的初始化而不会触发子类的初始化

/**
*   被动使用类字段演示二
*   常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发定义常量的类的初始化
**/
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);
    }
}

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

2.类加载的过程

2.1. 加载
在加载阶段（准确的说，是加载阶段中获取类的二进制字节流的动作），虚拟机主要完成一下三件事：
1）通过一个类的全限定名来获取类定义此类的二进制字节流；
2）将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构；
3）在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口。

2.2. 验证
目的：为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全
验证阶段大致包含四个阶段的检验动作：
文件格式验证、元数据验证、字节码验证、符号引用验证

2.2.1 【文件格式验证】（这个阶段的验证是基于二进制字节流进行的，只有通过了这个阶段的验证后，字节流才会进入内存的方法区中进行存储）
主要验证点：
1）是否以魔数0xCAFEBABE开头；
2）主、次版本好是否在当前虚拟机处理范围之内；
3）常量池中的常量中是否有不被支持的常量类型（检查常量tag标志）；
4）指向常量的各种索引值中是否指向不存在的常量或不符合类型的常量；
5）Class文件中各个部分的及文件本身是否有被删除的附加的其他信息。

2.2.2 【元数据验证】（主要目的是对类的元数据信息进行语义校验，保证不存在不符合Java语言规范的元数据信息）
主要包含的验证点：
1）这个类是否有父类（除java.lang.Object之外，所有的类都应该有父类）；
2）这个类的父类是否继承了不允许被继承的类（被final修饰的类）；
3）如果这个类不是抽象类，是否实现了其父类或接口之中的要求实现的所有方法；
4）类中的字段、方法是否与父类产生矛盾。

2.2.3 【字节码验证】（主要目的是通过数据流和控制流分析，对类的方法体进行校验分析，确定程序语义是合法的、符合逻辑的）
主要验证点：
1）保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作；
2）保证跳转指令不会跳转到方法体以外的字届码指令上；
3）保证方法体的类型转换是有效的。

2.2.4 【符号引用验证】（发生在解析阶段，确保解析东走正常运行；可以看作是对类自身以外（常量池中的各种符号引用）的信息进行匹配性检验）
主要验证点：
1）符号引用中通过字符串描述全限定名是否能找到对应的类；
2）在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段；
3）符号引用中的类、字段、方法的访问性（private,protected'public,default）是否可被当前类访问；

2.3. 准备
为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。
注意：
1）此处的【类变量】指被static修饰的变量，而不包括实例变量、实例变量将在对象实例化时随对象一起分配在Java堆中。
2）此处的【初始值】通常情况下是数据类型的零值。
特殊情况：
类字段的字段属性表存在ConstantValue属性（即常量），则在准备阶段变量value就会初始化为public static final int VALUE = 123;编译时javac将会为VALUE生成ConstantValue属性，在准备阶段虚拟机就会根据ConstantValue的设置将VALUE赋值为123

2.4. 解析（此阶段是虚拟机将常量池内的符号引用替换为直接引用的过程）
【符号引用】（Symbolic Referrences）：以一组符号来描述所引用的目标，符号可以是任何形式的字面量，只要使用时能无歧义地定位到目标即可。与虚拟机实现的布局无关，引用的目标并不一定已经加载到内存中。
【直接引用】（Direct Referrences）：可以直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。与虚拟机实现的内存布局有关，同一个符号引用在不同虚拟机实例上翻译出的直接引用一般不会相同。
在执行anewarray、checkcast、getfield、getstatic、instanceof、invokedynamic、invokeinterface、invokespecial、invostatic、involevirtual、ldc、ldc_w、multianewarray、new、putfield和putstatic这些用于操作符号引用的字节码指令前，先对他们所使用的符号引用进行解析。

    解析动作主要针对：()内为分别对应常量池的7种常量类型
    类或接口（CONSTANT_Class_info）
    字段(CONSTANT_Fieldref_info)
    类方法(CONSTANT_Metholdref_info)
    接口方法(CONSTANT_InterfaceMethodref_info)
    方法类型(CONSTANT_MethodType_info)
    方法句柄(CONSTANT_MethodHandle_info)
    调用点限定符(CONSTANT_InvokeDynamic_info)7类符号引用进行.

2.4.1 类或接口的解析
假设当前代码所处的类为D，如果要把一个从未解析过的符号引用N解析为一个类或接口C的直接引用，整个解析的过程需要以下3个步骤：
1）如果C不是一个数组类型，那虚拟机将会把代表N的全限定名传递给D的类加载器去加载这个类C。在加载过程中，由于元数据验证、字节码验证的需要，又可能触发其他相关类的加载动作，例如加载这个类的父类或实现的接口；
2）如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符会是类似“[Ljava/lang/Integer”的形式，那将会按照第一点的规则加载数组元素类型。如果N的描述符如前面假设的形式，需要加载的元素类型就是“java.lang.Integer”，接着由虚拟机生成一个代表此数组维度和元素的数组对象；
3）如果上面的步骤没有出现什么任何异常，那么C在虚拟机中实际上已经成为一个有效的类或接口了，但在解析完成之前还要进行符号引用验证，确认D是否具备对C的访问权限。如果发现不具备访问权限，将抛出java.lang.IllegalAccessError异常。

2.4.2 字段解析
要解析一个未被解析过的字段符号引用，首先将会对字段表内的class_index项中的索引的CONSTANT_Class_info符号引用进行解析，也就是字段所属的类或接口的符号引用。
如果在解析这个类或接口符号引用的过程中出现任何异常，都导致字段符号引用解析的失败；
如果解析成功完成，那将这个字段所属的类或接口用C表示，虚拟机按以下步骤对C进行后续字段的解析：
1）如果C本身就包含了简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用，查找结束；
2）否则，如果在C中实现了接口，将会按照继承关系从上往下搜索各个接口和它的父接口，如果接口中包含了简单名称和字段描述都与目标相匹配的字段，则返回这个字段的直接引用，查找结束；
3）否则，如果C不是java.lang.Object的话，将会按照继承关系从上往下递归搜索其父类，如果父类中包含简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束；
4）否则，查找失败，抛出java.lang.NoSuchFieldError异常。

2.4.3 类方法解析
类方法解析的第一个步骤与字段解析一样，也需要先解析出类方法表的class_index项中索引的方法所属的类或接口的符号引用，如果解析成功，用C表示这个类
1）类方法和接口方法的符号引用的常量类型定义是分开的，如果在类方法表中发现；class_index中索引的C是个接口，那就直接抛出java.lang.IncompatibleChangeError异常；

2. 如果通过了第1步，在类C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束；
   3）否则，在类C的父类中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束；
   4）否则，在类C实现的接口列表及它们的父接口之中递归查找是否有简单名称和描述符都与目标相匹配的方法，如果存在匹配的方法，说明类C是个抽象类，这时查找结束，抛出java.lang.AbstractMethodError异常；
   5）否则，方法查找失败，抛出java.lang.NoSuchMethodError异常。

2.4.4 接口方法解析
接口方法也需要先解析接口方法表的class_index项中索引的方法所属的类或接口的符号引用，如果解析成功，用C表示这个接口：
1）与类方法解析不同，如果在接口方法表中发现class_index中的索引C是个类而不是接口，那就直接抛出java.lang.IncompatibleChangeError异常；
2）否则，在接口C中查找是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束；
3）否则，在接口C的父接口中递归查找，直到java.lang.Object类（查找范围会包含Object类）为止，看是否有简单名称和描述符都与目标相匹配的方法，如果有则返回这个方法的直接引用，查找结束；
4）否则，方法查找失败，抛出java.lang.NoSuchMethodError异常。

由于接口中所有的方法默认都是public的，所以不存在访问权限的问题，因此接口方法的符号解析不会抛出java.lang.IllegalAccessError异常

2.5 初始化
初始化阶段是执行类构造器<clinit>()方法的过程以下列出<clinit>()方法执行过程中一些可能会影响程序运行行为的特点和细节：
1）<clinit>()方法是由编译期自助收集类中的所有类变量的赋值动作和静态语句块（static{}块）中的语句合并产生的，编译器收集的顺序由语句块在源文件中出现的顺序所决定，静态语句块中只能访问定义在静态语句块之前的变量，定义在静态语句块之后的变量，在前面的静态语句块只可以赋值，不能访问；

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

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

3. 由于父类的<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);
    }
   

4)<clinit>()方法对于类或接口并不是必需的，如果一个类中没有静态语句块，也没有对变量的赋值操作，那么编译器可以不为这个类生成<clinit>()方法；
5）接口中不能使用静态语句块，但仍然有变量初始化的赋值操作，因此接口与类一样也会生成<clinit>()方法。但接口与类不同的是，接口中的<clinit>()方法不需要先执行父接口的<clinit>()方法。只有当父接口中定义的变量使用时，父接口才会初始化。接口的实现类在初始化时一样不会执行接口的<clinit>()方法；
6）虚拟机会保证一个类的<clinit>()方法在多线程环境被正确地加锁、同步，如果多个线程同时去初始化一个类，那么只会有一个线程去执行这个类的<clinit>()方法，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。

*整理摘录自相关书籍