java Class 的加载时机

今天学到了类的加载相关知识，这里简要总结一下：

类从被加载到虚拟机内存中开始到卸载出内存为止，其生命周期包括：

加载，验证，准备，解析，初始化，使用和卸载七个阶段：

其中验证，准备，解析阶段称为连接阶段，但是这样的顺序并不是一成不变的，有时候解析过程会在初始化阶段之后完成，这也是为了满足动态绑定的需求，比如泛型的使用

1：类的加载：

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

1：通过一个类的全限定名来获取定义此类的二进制字节流

2：将这个字节流所代表的静态存储结构转化为方法区的运行时数据结构

3：在内存中生成一个代表这个类的java.lang.class对象，作为方法区这个类的各种数据的访问入口

虚拟机规范中并没有指明二进制字节流要从一个Class文件中获取，准确的说是根本没有指明要从哪里获取，怎样获取，这就很开放了，有以下几个方式获取：

1：从zip包中获取，这很常见，最终成为日后的jar，ear,war格式的基础

2：从网络上获取，典型的应用为applet

3：运行时计算生成，使用最多的就是动态代理技术，在java.lang.reflect.Proxy中，利用了ProxyGenerator.generateProxyClass来为特定的接口生成相应的“*$Proxy”的代理类的二进制字节流

4：由其他文件生成，例如JSP文件等等

相对于类加载过程的其他阶段，一个非数组类的加载阶段（准确的说是加载阶段中获取类的二进制字节流的动作）是开发人员可控性最强的，因为加载阶段既可以使用系统提供的引导类加载器来加载，亦可以由用户自定义的类加载器来完成，即重写一个类加载器的loadClass()方法

对于数组类而言，情况就有所不同，数组类不通过类加载器来加载创建，它是由java虚拟机直接创建的，但是数组类与类加载器仍然有密切的关系，因为数组类的元素类型例如 int[] a  它的数组类型是int，但是int是要靠类加载器去创建的

加载阶段完成之后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区中，方法区的数据存储格式有虚拟机实现自行定义，虚拟机规范未规定此区域的具体数据结构，然后在内存中实例化一个java.lang.Class类的对象（并没有明确规定是java堆中，对于hotspot而言，Class对象比较特殊，他虽然对象，但是存放在方法区里面），这个对象将作为程序访问方法区中的这些类型数据的外部接口

加载阶段与连接阶段的部分内容是交叉进行的

2：验证阶段是验证：

A：

1：Class文件的魔数是否为0xcafebabe,

2：主次版本号是否在当前虚拟机处理范围之内，

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

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

5：CONSTANT_UTF8_info型的常量中是否有不符合utf8编码的数据...

该验证的内容主要母的是保证输入的字节流能够真确的解析并存储于方法区之内，格式上符合描述一个java类型信息的要求，这阶段验证是基于二进制流字节流的方式进行，只有通过这个阶段的验证后，字节流才会进入内存的方法区中存储，所以后面的3个阶段全部是基于方法区的存储结构进行的，不会再操作字节流

B：元数据验证

说白了就是检验语法的正确性包括：

1：这个类是否有父类

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

3：如果这个类不是抽象类是否实现了父类或者接口之中的方法

4：类中的字段是否与父类产生矛盾

C：字节码验证

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

1：保证任意时刻操作数栈的数据类型和指令代码序列都能配合工作，例如不会出现类似这样的情况：在操作数栈放置了一个int数据类型的数据，使用时候却按long类型来加载到本地变量表中去

2：保证跳转指令不会跳转到方法体之外的字节码指令上

3：保证方法体中的类型转换是有效的，例如可以把一个子类对象赋值给父类数据类型，这是安全的，但是把父类对象赋值给子类数据类型的话这是危险和不合法的

D：符号引用验证

 验证类的字段，方法的可访问性等等

3：准备阶段

  准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。这个阶段中有两个产生混淆的概念，首先这时候进行内存分配的仅仅包括类变量，而不包括实例变量，实例变量将会在对象实例化的时候随着对象一起分配到java堆中，其次，这里所说的初始值是数据类型的零值，如：

public static int value=123;

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

如果类字段存在ConstantValue的属性，那么就在准备阶段变量value就被赋值为指定的值：

例如：

public static final int value = 123;

那么在准备阶段就会将value的值设置为123；

4：解析阶段

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

  a:符号引用：

  以一组符号来描述所引用的目标，符号可以以任何形式的字面量，只要使用是没有歧义的指向目标位置即可，符号引用的字面量形式明确定义在java虚拟机

b:直接引用：直接指向目标的指针，或者能够间接访问到目标的句柄，是与虚拟机实现的内存布局相关的

 解析动作主要针对类或者接口，字段，类方法，接口方法，方法类型，方法句柄和调用点限定符7类符号引用进行，分别对应于常量池的CONSTATNT_Class_info,CONSTANT_Fieldref_info,CONSTANT_Methoddref_info,CONSTANT_InterfaceMethodref_info,CONSTANT_MethodType_info,CONSTANT_MethodHandle_info和CONSTANT_InvokeDynamic_info七种常量类型，主要是前四种的解析过程

1：类或者接口的解析

假设当前代码所处的类为D，如果要把一个从未解析的符号引用N解析为一个类或者接口C的直接引用，那么虚拟机完成整个解析过程需要3个步骤：

   a:如果C不是数组类型，那么虚拟机将会把代表N的全限定名传递给D的类加载器去加载这个类C，在加载过程中由于元数据验证，字节码验证的需要，又可能触发其他的相关列进行加载动作，一旦出现异常，解析过程就宣告失败！

   b:如果C是一个数组类型，并且数组的元素类型为对象，也就是N的描述符回事类似【Ljava/lang/Integer】的形式，那将会按照a点的规则加载数组元素类型，例如：String[] strArray = new String[10]它的数组元素就是String对象，那么他就会先加载String这个对象类，如果N的描述符如前面所假设的形式，需要加载的类型是java/lang/Integer，接着就有虚拟机生成一个代表此数组维度和元素的数组对象;

  c:如果上面的步骤没有出现任何异常，那么C就会就会成为一个有效的类或者接口了

2：字段解析

  要解析一个未被解析过的字段符号引用，首先将会对字段表内class_index项中的索引CONSTANT_Class_info符号引用进行解析，也就是字段所属的类或者接口的符号引用，如果这个过程出现异常就会解析失败，如果解析完成，那么这个字段所属的类或者接口用C表示，虚拟机规范要求按照如下步骤进行后续字段的搜索

  a:如果C本身包含了简单名称和字段描述符都与目标相匹配的字段，则返回这个字段的直接引用，查找结束

  b:否则，如果在C中实现了接口，将会按照继承关系递归搜索各个接口和他的父接口，如果接口中包含简单字段描述符都与目标相匹配的字段，则查找结束

  c:否则，如果C不是java.lang.Object的话，将会按继承关系进行递归搜索其父类，如果父类中包含了简单名称和字段描述符都与目标相匹配的字段，则放回这个字段的直接引用，查找结束。

  d:否则查找失败

 在实际应用中，如果一个同名字段同时出现在C的接口和父类中或者同时在自己或者父类的多个接口中出现，那么编译器就会拒绝编译：如一下代码：

public class FieldResolution {    interface Interface0{        int a = 0;    }    interface Interface1 extends Interface0{        int a = 1;    }    interface Interface2 {        int a = 2;    }    static class Parent implements Interface1 {        public static int a = 3;    }    static class Sub extends Parent implements Interface2{       // public static int a = 4;    }    public static void main(String[] args){        System.out.println(Sub.a); //这里就会报错    }}

3，类方法的解析

与上述类似

5：初始化阶段
    类初始化阶段是类加载的最后一步，前面的类加载过程中，除了在加载阶段用户应用程序可以通过自定义类加载器参与之外，其余动作完全由虚拟机主导可控制，到了初始化阶段，才真正开始执行类中定义的java程序代码或者是字节码。

初始化阶段是执行类构造器<clinit>()方法的过程：看一看<clinit>()运行的特点和细节

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

public class Test{   static {     i=0;         //给变量赋值可以编译通过    System.out.println(i);//非法向前引用}static int i = 1;}

b:<clinit>()方法与类的构造器不同，他不需要显示的调用父类的构造器，虚拟机会保证在子类的<clinit>()方法执行之前，父类的<clinit>()方法已经执行完毕，因此在虚拟机中第一个被执行的<clinit>()方法肯定是java.lang.Object.

c:由于父类的<clinit>()方法先执行，也就意味着父类中定义的静态语句块要优先于子类的变量赋值操作：如：

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);    }

字段b的值将会是2而不是1

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

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

有且仅有5中情况必须立即对类进行初始化：

1：遇到new,getstaic ,putstatic,or invokestatic这4个字节码指令时候，如果没有进行过初始化，则需要先触发其初始化，生成这4条指令的java代码场景是：使用new关键字实例化对象的时候，读取或者设置一个类的静态字段的时候（final字段的变量除外）以及调用一个类的静态方法的时候

2：使用java.lang.reflect包的方法对类进行反射调用的时候，如果类没有初始化就会触发其初始化。

3：当初始化一个类的时候，如果发现其父类还没有被初始化就先初始化其父类

4：当虚拟机启动的时候，用户指定一个要执行的主类，虚拟机会先初始化这个主类

5：当使用jdk7的冬天语言支持的时候，如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokestatic的方法的句柄的时候，并且这个方法句柄对应的类没有进行过初始化，则需要进行初始化。

上面这五种是对一个类的主动引用，除此之外，所有引用类的方式都不会触发初始化，称为被动引用

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

/*** 被动引用的例子* 通过子类引用父类的静态字段，不会导致子类的初始化* */public class SuperClass {    public int a = 3;    static {        System.out.println("SuperClass init");    }    public static int value=123;}

public class SubClass extends SuperClass {    public static String initSub(){        return "beginning invoke me!";    }    public static int a = 4;    //优先于方法执行    static {        System.out.println("Subclass init");    }}

public class NotInitialization {    public static void main(String[] args){        /*        *        * 使用父类的静态字段时候只会初始化直接定义这个字段的类才会被加载        *        * */        System.out.println(SubClass.value);       /* SubClass sc = new SubClass();        System.out.println(sc.a);        */    }}

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

public class NotInitialization{

       public static void main(String[] args){

              SuperClass[] sca = new SuperClass[10];

   }

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

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

public class NotInitialization {    public static void main(String[] args){        /*        *        * 使用父类的静态字段时候只会初始化直接定义这个字段的类才会被加载        *        * */        System.out.println(ConstClass.HELLOWORD);       /* SubClass sc = new SubClass();        System.out.println(sc.a);        */    }}

没有输出“ConstClass init”,因为虽然在java源码中引用了ConstClass类中的常量HELLOWORLD，但是其实在编译阶段通过常量传播优化，已经将此常量的值“Hellowerd”存储到NotInitialization类的常量池中，以后NotInitialization对常量ConstClass.HELLOWORD的引用实际都被转化为NotInitiallization类对自身常量池的引用了