JVM类加载机制

概念：

• JRE(Java运行环境)：所有的Java 程序都要在JRE下才能运行。
• JDK：开发者编译、调试java程序用的开发工具包。JDK的工具也是Java程序，也需要JRE才能运行。在JDK的安装目录下有一个名为jre的目录，用于存放JRE文件。
• JVM(Java虚拟机)是JRE的一部分。它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。JVM有自己完善的硬件架构，如处理器、堆栈、寄存器等，还具有相应的指令系统。使用JVM就是为了支持与操作系统无关，实现跨平台。JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。

JVM 类加载机制详解：

JVM类加载机制分为五个部分：

• 加载：

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

• 验证 ：
  为了确保Class文件的字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身的安全。包括文件格式验证，元数据验证，字节码验证，符号引用验证。可以采用-Xverifynone参数来关闭大部分的类验证措施，以缩短虚拟机类加载的时间
• 准备：
  为类变量分配内存并设置类变量初始值的阶段，这些变量所使用的内存都将在方法区中进行分配。

public static int v = 8080; #变量v在准备阶段过后的初始值为0而不是8080，将v赋值为8080的putstatic指令是程序被编译后，存放于类构造器()方法之中，把value赋值为123的动作将在初始化阶段才会执行。
public static final int v = 8080; #在编译阶段会为v生成`ConstantValue`属性，在准备阶段虚拟机会根据`ConstantValue`属性将v赋值为8080。

• 解析：
  是虚拟机将常量池中的符号引用替换为直接引用的过程。符号引用就是class文件中的CONSTANT_Class_info，CONSTANT_Field_info，CONSTANT_Method_info

符号引用：引用的目标并不一定要已经加载到内存中。各种虚拟机实现的内存布局可以各不相同，但是它们能接受的符号引用必须是一致的，因为符号引用的字面量形式明确定义在Java虚拟机规范的Class文件格式中。
直接引用：指向目标的指针，相对偏移量或是一个能间接定位到目标的句柄。如果有了直接引用，那引用的目标必定已经在内存中存在。

• 初始化：
  初始化阶段是执行类构造器方法的过程。方法是由编译器自动收集类中的类变量的赋值操作和静态语句块中的语句合并而成的。虚拟机会保证方法执行之前，父类的方法已经执行完毕。如果一个类中没有对静态变量赋值也没有静态语句块，那么编译器可以不为这个类生成()方法。

什么时候需要对类进行初始化？
使用new该类实例化对象的时候；
读取或设置类静态字段的时候（但被final修饰的字段，在编译器时就被放入常量池的静态字段除外static final）；
调用类静态方法的时候；
使用反射Class.forName(“xxxx”)对类进行反射调用的时候，该类需要初始化；
初始化一个类的时候，有父类，先初始化父类（注：1. 接口除外，父接口在调用的时候才会被初始化；2.子类引用父类静态字段，只会引发父类初始化）；
被标明为启动类的类（即包含main()方法的类）要初始化；
当使用JDK1.7的动态语言支持时，如果一个java.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。

通过子类引用父类的静态字段，只会触发父类的初始化，而不会触发子类的初始化。
定义对象数组，不会触发该类的初始化。
常量在编译期间会存入调用类的常量池中，本质上并没有直接引用定义常量的类，不会触发定义常量所在的类。
通过类名获取Class对象，不会触发类的初始化。
通过Class.forName加载指定类时，如果指定参数initialize为false时，也不会触发类初始化，其实这个参数是告诉虚拟机，是否要对类进行初始化。
通过ClassLoader默认的loadClass方法，也不会触发初始化动作。

Java语言系统自带三个类加载器:

虚拟机设计团队把加载动作放到JVM外部实现，以便让应用程序决定如何获取所需的类：

• Bootstrap ClassLoader 最顶层的启动类加载器，主要加载核心类库，%JRE_HOME%\lib下的jar包和class文件。或通过-Xbootclasspath参数指定路径中的类。
• Extention ClassLoader 扩展的类加载器，加载目录%JRE_HOME%\lib\ext目录下的jar包和class文件。
• Appclass Loader应用程序类加载器，加载用户路径的classpath的所有类。
  

三个类加载器的加载顺序

• 先创建个项目，再创建个Test.java
  

java.lang.ClassLoader cl = Test.class.getClassLoader();        
System.out.println("ClassLoader is:"+cl.toString());
System.out.println("ClassLoader\'s parent is:"+cl.getParent().toString()); 
System.out.println("ClassLoader\'s grand father is:"+cl.getParent().getParent().toString()); 

• 自己编写的Test.class文件是由AppClassLoader加载的
• AppClassLoader的parent是ExtClassLoader，ExtClassLoader的parent是null
• BootStrapClassLoader、ExtClassLoader、AppClassLoader都是加载指定路径下的jar包

JVM通过双亲委派模型进行类的加载，也可以通过继承java.lang.ClassLoader实现自定义的类加载器。

当一个类加载器收到类加载任务，会先交给其父类加载器去完成，因此最终加载任务都会传递到顶层的启动类加载器，只有当父类加载器无法完成加载任务时，才会尝试自己执行加载任务。采用双亲委派的一个好处是比如加载位于rt.jar包中的类java.lang.Object，不管是哪个加载器加载这个类，最终都是委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载器最终得到的都是同样一个Object对象。
加载过程

• 首先通过Class c = findLoadedClass(name);判断一个类是否已经被加载过。
• 如果没有被加载过执行if (c == null)中的程序，遵循双亲委派的模型，首先会通过递归从父加载器开始找，直到父类加载器是Bootstrap ClassLoader为止。
• 最后根据resolve的值，判断这个class是否需要解析。

一个实例

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; 
        } 
    } 
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 class jvm {
    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); 
        }
}

结果

Singleton输出结果：1 0

首先执行main中的Singleton singleton = Singleton.getInstance();
加载：加载类Singleton
准备：为静态变量分配内存，设置默认值。这里为singleton(引用类型)设置为null,value1,value2（基本数据类型）设置默认值0
初始化（按照赋值语句进行修改）：
    执行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

Singleton2输出结果：1 1

执行main中的Singleton2 singleton2 = Singleton2.getInstance2();
加载：加载类Singleton2
准备：为静态变量分配内存，设置默认值。这里为value1,value2（基本数据类型）设置默认值0,singleton2(引用类型)设置为null,
初始化（按照赋值语句进行修改）：
    执行public static int value2 = 0;
    此时value2=0(value1不变，依然是0);
    执行
    private static Singleton singleton = new Singleton();
    执行Singleton2的构造器：value1++;value2++;
    此时value1，value2均等于1,即为最后结果

参考文献：https://blog.csdn.net/briblue/article/details/54973413
https://yq.aliyun.com/articles/518315
https://blog.csdn.net/noaman_wgs/article/details/74489549
http://www.importnew.com/30567.html