jvm类加载机制

JVM类加载分为5个过程：

• 加载
• 验证
• 准备
• 解析
• 初始化

分别阐述五个个过程所执行的操作

加载：
加载时总共做三个工作：
1.通过一个类的全限定名来获取定义此类的二进制字节流。
2.将这个字节流所代表的静态存储结构转化为方法去运行时的数据结构
3.在内存中生成一个代表这个类的java.lang.class的对象，作为方法区这个类的各种数据的访问接口。

**验证：**简而言之验证部分就是验证这个类中的所有是否符合java语言机制所符合所允许的语法
具体操作如下：

1. 文件格式检验：
   检验字节流是否符合Class文件格式的规范，并且能被当前版本的虚拟机处理。检验可能包含下列几种：是否以魔数开头、主次版本号是否在虚拟机的处理范围之内，常量池中的常量是否不被支持、文件是否被删除或附加什么信息等等。
   只有通过文件格式检验的二进制字节流才能进入内存的方法区进行存储，所以后面的3个检验阶段都是基于方法区的存储结构进行的，不会在操作字节流。
2. 元数据检验：
   对字节码描述的信息进行语义分析，以保证其描述的内容符合Java语言规范的要求。
   验证点包括：是否有父类（除了object）、父类是否继承了不可被继承的类（被final修饰的类）、如果这个类不是抽象类，是否实现了其父类或接口之中要求实现的所有方法、类中的方法和字段是否与父类产生矛盾（覆盖了父类的final字段、出现不合规矩的方法重载等）。
   元数据检验主要是对类的元数据信息进行语义校验，保证不符合Java语言规范的元数据信息不存在。
3. 字节码检验：
   通过数据流和控制流分析，确定程序语义是合法、符合逻辑的。第二阶段是对元数据信息中的数据类型做了检验，这一阶段是对类的方法体进行校验分析，保证被校验类的方法在运行时不会做出危害虚拟机安全的事情。
   检验点包括：保证任意时刻操作数栈的数据类型与指令代码序列都能配合工作、保证指令跳转不会跳转到方法体之外的地方、保证方法体内的类型转换都是有效的。
   事实上，即便是经过字节码检验后的方法体也不一定是安全的。
4. 符号引用检验
   最后一个检验发生在虚拟机将符号引用转化为直接引用时，这个转化动作将在连接的第三阶段–解析阶段中发生的。符号引用检验可以看作是对类自身以外（常量池中的各种符号引用）的信息进行匹配性校验。
   校验点：符号引用中通过字符串描述的全限定名是否能找到对应的类、在指定类中是否存在符合方法的字段描述符以及简单名称所描述的方法和字段、符号引用中的类、字段、方法的访问权限是否能让当前类访问到等。
   符号引用检验的目的是确保解析动作的正常执行，如果无法通过符号引用检验，将会抛出java.lang.IncompatibleClassChangeError异常的子类，如IllegalAccessError、NoSuchfiledError、NoSuchMethodError等。

准备：
准备阶段是正式为类变量分配内存并设置类变量初始值的阶段。这些变量所使用的内存将在方法区中进行分配。此时进行内存分配的仅包括类变量（被static修饰的变量），而不包括实例变量
另外，在这里分配的静态类变量是将其值定义为0等默认值，而不是我们定义的。因为这时尚未执行任何Java方法，我们定义的赋值的putStatic指令是程序被编译后，存放在类构造器()方法中，所以正确的赋值将在初始化阶段执行。
　　如果类变量被final修饰，那么在这种情况下，在编译时Javac将会为该变量生成ConstantValue属性，在准备阶段虚拟机会根据该属性设置类变量的正确值。

解析：
　解析阶段是虚拟机将常量池内的符号引用替换为直接引用的过程。
a、符号引用：以一组符号来描述所引用的目标，符号可以是任何形式字面量，只要使用时无歧义地定位到目标就行。
b、 直接引用：直接引用是直接指向目标的指针、相对偏移量或是一个能间接定位到目标的句柄。引用的目标已经在内存中存在。
　　虚拟机实现可以根据需要来判断到底在类被加载器加载时就对常量池中的符号引用进行解析，还是等到一个符号引用将要被使用时才去解析它。解析动作主要针对类或接口、字段、类方法、接口方法、方法类型、方法句柄和调用点限定符7类符号引用进行。

初始化：
类加载的最后一步，真正执行类中定义的Java程序代码（字节码）。
根据代码给的初始化变量

下面我们来看一道例题，以我们最常见的单例模式为例：

class Singleton{
    private static Singleton singleton = new Singleton();
    public static int value1;
    public static int value2 = 0;
    private Singleton(){
        value1++;
        value2++;
    }
    public static Singleton getInstance(){
        return singleton;
    }
}
public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("Singleton1 value1:" + singleton.value1);
        System.out.println("Singleton1 value2:" + singleton.value2);
 
        Singleton2 singleton2 = Singleton2.getInstance2();
        System.out.println("Singleton2 value1:" + singleton2.value1);
        System.out.println("Singleton2 value2:" + singleton2.value2);
    }

输出结果
Singleton1 value1 : 1
Singleton1 value2 : 0

分析：

1 首先执行main中的Singleton singleton = Singleton.getInstance();
2 类的加载：加载类Singleton
3 类的验证
4 类的准备：为静态变量分配内存，设置默认值。这里为singleton(引用类型)设置为null,value1,value2（基本数据类型）设置默认值0
5 类的初始化（按照赋值语句进行修改）：
执行private static Singleton singleton = new Singleton();
执行Singleton的构造器：value1++;value2++; 此时value1，value2均等于1
执行
public static int value1;
public static int value2 = 0;
此时value1=1，value2=0，理论上这里value2=1 但是这里由于顺序执行 public static int value2 = 0; 将value2=1给覆盖了

举一反三：你觉得下面这道题的结果：

class Singleton2{
    public static int value1;
    public static int value2 = 0;
    private static Singleton2 singleton2 = new Singleton2();
 
    private Singleton2(){
        value1++;
        value2++;
    }
 
    public static Singleton2 getInstance2(){
        return singleton2;
    }
 
}
 
public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("Singleton1 value1:" + singleton.value1);
        System.out.println("Singleton1 value2:" + singleton.value2);
 
        Singleton2 singleton2 = Singleton2.getInstance2();
        System.out.println("Singleton2 value1:" + singleton2.value1);
        System.out.println("Singleton2 value2:" + singleton2.value2);
    }

说出运行的结果：
Singleton2 value1 : 1
Singleton2 value2 : 1