概念

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

2. 生命周期： 类从被加载到虚拟机内存中开始，到卸载出内存为止，它的整个生命周期包括：加载、验证、准备、解析、初始化、使用和卸载七个阶段

3. 静态绑定：即前期绑定。在程序执行前方法已经被绑定，此时由编译器或其它连接程序实现。针对java，简单的可以理解为程序编译期的绑定。java当中的方法只有final，static，private和构造方法是前期绑定的。

4. 动态绑定：即晚期绑定，也叫运行时绑定。在运行时根据具体对象的类型进行绑定。在java中，几乎所有的方法都是后期绑定的。

类加载生命周期各过程示意图

其中，加载、验证、准备、初始化和卸载这五个阶段的顺序是确定的，类的加载过程必须按照这种顺序按部就班的开始。

而解析阶段则不一定：它在某些情况下可以在初始化阶段之后开始，这是为了支持Java语言的运行时绑定（也成为动态绑定或晚期绑定）。

注意：
这里的几个阶段是按顺序开始，而不是按顺序进行或完成，因为这些阶段通常都是互相交叉地混合进行的，通常在一个阶段执行的过程中调用或激活另一个阶段。

类加载过程

1. 加载

加载是类加载过程的第一个阶段，在加载阶段，虚拟机需要完成以下三件事情：

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

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

3、在内存中生成一个代表这个类的java.lang.Class对象，作为对方法区中这些数据的访问入口。

注意：

第1条中的二进制字节流并不只是单纯地从Class文件中获取，比如它还可以从zip包中获取、从网络中获取（最典型的应用便是Applet）、运行时计算生成（使用最多的场景就是动态代理技术），由其他文件生成（如JSP应用）等。

对于类加载的其他阶段而言，加载阶段（准确地说，是加载阶段获取类的二进制字节流的动作）是可控性最强的阶段，因为开发人员既可以使用系统提供的类加载器来完成加载，也可以自定义自己的类加载器来完成加载。

加载阶段完成后，虚拟机外部的二进制字节流就按照虚拟机所需的格式存储在方法区之中，然后在内存中实例化一个java.lang.Class类的对象，该对象将作为程序访问方法区中的这些类型数据的外部接口。

2. 验证

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

不同的虚拟机对类验证的实现可能会有所不同，但大致都会完成以下四个阶段的验证：文件格式的验证、元数据的验证、字节码验证、符号引用验证。

• 文件格式的验证：验证字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。
  该验证的主要目的是保证输入的字节流能正确地解析并存储于方法区之内。经过该阶段的验证后，字节流才会进入内存的方法区中进行存储，后面的三个验证都是基于方法区的存储结构进行的。

• 元数据验证：对类的元数据信息进行语义校验（其实就是对类中的各数据类型进行语法校验），保证不存在不符合Java语法规范的元数据信息。

• 字节码验证：该阶段验证的主要工作是进行数据流和控制流分析，对类的方法体进行校验分析，以保证被校验的类的方法在运行时不会做出危害虚拟机安全的行为。

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

3. 准备

准备阶段是正式为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中分配。对于该阶段有以下几点需要注意：

1、这时候进行内存分配的仅包括类变量（static），而不包括实例变量，实例变量会在对象实例化时随着对象一块分配在Java堆中。

2、这里所设置的初始值通常情况下是数据类型的零值。
如：public static int value = 123；变量value再准备阶段过后的初始值位0而不是123，value被赋值123的动作在初始化阶段才会执行。

3、如果类字段的字段属性表中存在ConstantValue属性，即同时被final和static修饰的变量，那么在准备阶段变量value就会被初始化为ConstValue属性所指定的值。如：public static final int value = 123; 该value在准备阶段过后的值为123

4. 解析

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

前面说解析阶段可能开始于初始化之前，也可能在初始化之后开始，虚拟机会根据需要来判断，到底是在类被加载器加载时就对常量池中的符号引用进行解析（初始化之前），还是等到一个符号引用将要被使用前才去解析它（初始化之后）。

对同一个符号引用进行多次解析请求时很常见的事情，除invokedynamic指令以外，虚拟机实现可能会对第一次解析的结果进行缓存（在运行时常量池中记录直接引用，并把常量标示为已解析状态），从而避免解析动作重复进行。

解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点7类符号引用进行，分别对应于常量池中的CONSTANT_Class_info、CONSTANT_Fieldref_info、CONSTANT_Methodref_info、CONSTANT_InterfaceMethodref_info、CONSTANT_MethodType_info、CONSTANT_MethodHandle_info和CONSTANT_MethodInvokeDynamic_info7种常量类型。

4种引用的解析过程：

1. 类或接口的解析：

判断所要转化成的直接引用是对数组类型，还是普通的对象类型的引用，从而进行不同的解析。

2. 字段解析：

对字段进行解析时，会先在本类中查找是否包含有简单名称和字段描述符都与目标相匹配的字段，如果有，则查找结束；如果没有，则会按照继承关系从上往下递归搜索该类所实现的各个接口和它们的父接口，还没有，则按照继承关系从上往下递归搜索其父类，直至查找结束，查找流程如下图所示：

最后需要注意：理论上是按照上述顺序进行搜索解析，但在实际应用中，虚拟机的编译器实现可能要比上述规范要求的更严格一些。如果有一个同名字段同时出现在该类的接口和父类中，或同时在自己或父类的接口中出现，编译器可能会拒绝编译。

3. 类方法解析：

对类方法的解析与对字段解析的搜索步骤差不多，只是多了判断该方法所处的是类还是接口的步骤，而且对类方法的匹配搜索，是先搜索父类，再搜索接口。

4. 接口方法解析：

与类方法解析步骤类似，知识接口不会有父类，因此，只递归向上搜索父接口就行了。

5. 初始化

初始化是类加载过程的最后一步，到了此阶段，才真正开始执行类中定义的Java程序代码。

在准备阶段，变量已经被赋过一次系统要求的初始值，而在初始化阶段，则根据程序员通过程序指定的主观计划去初始化类变量和其他资源。即，初始化阶段是执行类构造器<clinit>()方法的过程。

理解与区别：

1. 类构造器<clinit>()可以这样记忆：class的前缀cl + init = clinit
2. 类构造器 与 类的构造函数 是不一样的，类构造函数，即我们通常讲的构造函数，也称为实例构造器<init>()方法，如下代码：

public class test {
    public test() {}   //构造函数
}

类构造器<clinit>()方法包含如下两部分内容：

1. 编译器自动收集类中的所有 类变量 的赋值动作
2. 静态语句块(static{})

注意：

1. 编译器收集类变量赋值的顺序，是由语句在源文件中出现的顺序所决定的，即，写在代码里的顺序，如下，a会先被赋值，然后是b：

public static int a = 1;
public static int b = 2;

2. 静态语句块中只能访问到定义在静态语句块之前的变量，定义在它之后的变量，在静态语句块中可以赋值，但不能访问，如下代码：

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

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

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

static class Parent {
    static int i = 1;
    static {
        i = 2;   
    }
}
static class Sub extends Parent {
    public static int B = A;  
}
public static void main(String[] args) {
    System.out.println(Sub.B);  // 打印结果是2
}

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

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

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

static class DeadLoopClass {
    static {
        /* 若果不加上这个if语句，编译器将提示"Initializer does not complete normally" 并拒绝编译*/
        if (true) {
            System.out.println(Thread.currentThread() + "init DeadLoopClass");
            while (true) {}
        } 
    }

    public static void main (String[] args) {
        Runnable script = new Runnable () {
            public void run () {
                System.out.println(Thread.currentThread() + "start");
                DeadLoopClass dlc = new DeadLoopClass();
                System.out.println(Thread.currentThread() + " run over");
            }
        };

        Thread t1 = new Thread(script);
        Thread t2 = new Thread(script);
        t1.start();
        t2.start();
    }
}

运行结果如下，即一条线程在死循环以模拟长时间操作，另外一条线程在阻塞等待：

Thread[Thread-0,5,main] start
Thread[Thread-1,5,main] start
Thread[Thread-0,5,main] init DeadLoopClass

通过代码来看初始化顺序：

public class GrandParents {
    public int count = 0;
    static {
        System.out.println("GrandParents");
    }
}    

public class Parents extends GrandParents {
    static {
        System.out.println("Parents init!");
    }
 
    public static int value = 123;
 
    public Parents()  {
        System.out.println("init Parents");
    }
}
public class Child extends Parents {
    static {
        System.out.println("Child init");
    }
 
    static int a;
 
    public Child ()
    {
        System.out.println("init Child");
    }
}
public class Test {
    public static void main(String[] args) {
        System.out.println(Child.value);
        System.out.println("==============");
        Child child = new Child();
        System.out.println(child.count);
    }
}

执行结果：

GrandParents
Parents init!
123
==============
Child init
init Parents
init Child
0

小结：
无继承的的初始化顺序：

有继承的初始化顺序：

初始化的条件

虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化：

• 遇到new、getstatic、putstatic、invokestatic这四条字节码指令时，如果类还没有进行过初始化，则需要先触发其初始化。生成这四条指令最常见的Java代码场景是：使用new关键字实例化对象时、读取或设置一个类的静态字段（static）时（被static修饰又被final修饰的，已在编译期把结果放入常量池的静态字段除外）、以及调用一个类的静态方法时。

• 使用Java.lang.refect包的方法对类进行反射调用时，如果类还没有进行过初始化，则需要先触发其初始化。

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

• 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先执行该主类。

  虚拟机规定只有这四种情况才会触发类的初始化，称为对一个类进行主动引用，除此之外所有引用类的方式都不会触发其初始化，称为被动引用。