1.前言

每当我们编写一个Java程序的时候都会经历，编写，编译，运行的一个过程。编译的过程是通过Java的编译器来帮我们完成，他帮我们把java文件编译成class二进制进制文件，并保存在硬盘中，但是当我们要运行程序的时候，我们需要将class文件加载进内存，启动JVM虚拟机，虚拟机帮我们开启一个线程，来执行我们编写的代码，而将字节码文件加载进内存的过程就是需要ClassLoader,即类加载器。
在介绍类加载器之前我们先看一段代码。

class Singleton {
    private static Singleton singleton = new Singleton(); //1
    public static int counter1;                           //2
    public static int counter2 = 0;                       //3

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

public class ClassLoaderClient {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1 = " + singleton.counter1);
        System.out.println("counter2 = " + singleton.counter2);
    }
}

Singleton类很简单，声明了3个静态变量，对Singleton的构造方法进行了初始化，并且对Singleton进行了单例化。好让我们思考一下在main方法中程序运行的结果是什么？
很多朋友，可能会嗤之以鼻，就会说，这还不简单，很显然，counter1,counter2 结果都为2。可是结果真的是这样吗？？我们看一下结果。

// 输出结果
counter1 = 1
counter2 = 0

是不是出乎意料了，嘿嘿，好玩的还在后面，我们将第1行代码和第2,3行对调，就像这样。

public static int counter1;                           
public static int counter2 = 0;                       
private static Singleton singleton = new Singleton();

当我们把程序修改成这样之后，程序的运行结果就成这样了。

// 输出结果
counter1 = 1
counter2 = 1

我知道大家心里肯定都充满了疑惑，为什么仅仅是更改了几行代码，输出结果就发生了改变呢？带着这些疑惑，我们学习完下面的内容，“类加载”的相关概念，这个问题就是小菜一碟啦！

2.类加载的过程概述

一般的，一个类的加载要经过三个过程，即加载 => 连接 => 初始化。而每个过程都需要做一些事情，保证类能够正确的加载进内存，让我们可以正确的使用对象。

类加载的过程.png

1.加载
查找并加载二进制文件到内存
2.连接
- 2.1验证：确保被加载类的正确性
- 2.2准备：为类的静态变量(类变量)分配内存，并为其初始化为默认值，基本数据类型是其默认值,引用数据类型是null。
- 2.3解析：把类中的符号引用转换为直接引用。
3.初始化
为类的静态变量赋予正确的初始值。这里的初始值，和连接中的初始值，不是同一个初始值，这里的初始值，是我们自己为该静态变量显式的赋予初始值。
public static int counter1 = 10 // 将10赋值给counter1就是显示的初始化

3.类加载分析

3.1加载

类的加载指的是类加载器将类的.class文件中的二进制数据读入到内存中，将其放在运行时数据区的方法区内，然后在堆区创建一个 java.lang.Class对象，用来封装类在方法区内的数据结构，类的加载的最终产品是位于堆区中的 Class对象。Class对象封装了类在方法区内的数据结构，并且向Java程序员提供了访问方法区内的数据结构的接口。Java中的反射机制就是操作堆内存中的java.lang.Class对象。

3.2连接

类被加载后，就进入连接阶段。连接就是将已经读入到内存的类的二进制数据合并到虚拟机的运行时环境中去。

3.2.1类的验证

验证就是对Class文件的语法,文法,格式规范进行验证。放置恶意用户对Class文件进行修改，破坏程序的执行。
验证主要包含以下几个步骤。

1类文件的结构检查
确保类文件遵从Java类文件的固定格式。
2语义检查
确保类本身符合Java语言的语法规范，比如验证final的类不能被继承，final修饰的方法，子类不能重写等。
3字节码验证
确保字节码流可以被Java虚拟机安全地执行，字节码流代表Java方法（包括实例方法和静态方法）,他是由被称作操作吗的单字节执行组成的序列，每个操作码后都跟随一个或多个操作数(类似汇编语言)。字节码验证步骤会检查每个操作码是否合法，即是否有着合法的操作数。
4二进制兼容性的验证
确保相互引用的类之间的协调一致，例如，Study类的getoStudy()方法调用Student里的studyEnglish（)方法，Java虚拟机在验证Worker类的时候会检查方法去内是否存在Student类的StudyEnglish()方法，加入不存在(比如用Student类用Jdk1.6编译，Study类Jdk1.5编译)，就会抛出NoSuchMethodError错误。

3.2.2类的准备

在准备阶段，Java虚拟机为类的静态变量分配内存，并设置默认的初始值。例如下面的Sample类，在类的准备阶段，将int类型的静态变量a分配4个子节的内存空间，并赋予默认值0，为long类型的静态变量b分配8个子节的内存空间，并赋予0

public class Sample {
  private static int a = 1;
  private static long b;
  static {
     b = 2;
  }
}

3.2.3类的连接

在类的解析阶段，Java虚拟机会把类的而精致数据种的符号引用替换为直接引用。例如Study类的gotoStudy方法会引用Student的studyEnglish()方法

public void gotoStudy() {
  student.studyEnglish();
}

在Study类的二进制数据中，包含对Student类studyEnglish()方法的符号引用，它由方法的全名和相关的描述符构成，在解析阶段，Java虚拟机会把这些符号引用用一个指针替换，该指针指向Student类studyEnglish()方法在方法区内的内存位置，这个指针就是直接引用。

3.3初始化

在初始化阶段，java虚拟机执行类的初始化语句，为类的静态变量赋予初始值。在程序中静态变量初始化由两种途径:(1)在静态变量的声明处进行初始化 (2)在静态代码块中进行初始化。例如在以下代码中静态变量a,b就被显示的初始化，而静态变量c没有被显式初始化，它将保持默认值0。

public class Sample {
  private static int a = 1;
  private static long b;
  private static long c;
  static {
     b = 2;
  }
}

3.3.1类初始化步骤

加入这个类未被加载和连接，那就先进行加载和连接。
加入这个类存在直接的父类，并且这个父类没有初始化，那么就先初始化父类。
假如类中存在初始化语句,那就依此执行这些初始化语句。

3.3.2类初始化的时机

而在Java中Class文件的加载还是有条件的并不是，想怎么加载就怎么加载，这样的话可就乱了套了。因此JVM对Class文件的加载时机做了说明。

3.3.2.1Java程序对类的使用分为两种方式。

主动使用(6种方式)
所有的Java虚拟机加载Class文件,必须在每个类或接口被Java程序“首次主动使用”时才初始化他们。
- 创建类的实例。
- 初始化一个类的子类。
- 访问某个类或接口的静态变量，或者对该静态变量赋值。
- 调用类的静态方法。
- 反射,如 Class.forName("com.test.user")
- Java虚拟机启动时被标明为启动类的类,就是通过java命令执行包含main方法的类，如 java Test

// 1.创建类的实例
User user = new User();
        
// 2.初始化一个类的子类
Class Father {}
Class Son extends Father {}
Son son = new Son();
        
// 3.访问类/接口的静态变量，或者对该静态变量赋值
String var1 = StaticClassTest.COUNTER1;
        
// 4.调用类的静态方法
StaticClassTest.method1();
        
// 5.反射
Class aClass = Class.forName("com.test.jvm.AJvm.classLoaderSeq.context.Son");

被动使用
除了以上六种情况，其他使用Java类的方式都被看作是对类的被动使用，都不会导致类的初始化

3.3.2.2一些注意事项

1.接口的初始化
当Java虚拟机初始化一个类的时候，要求它的父类都已经被初始化，但这个规则不适用于接口。
- 在初始化一个类时，并不会初始化它所实现的接口。
- 在初始化一个接口的时候，并不会初始化它的父接口。
因此，一个父接口并不会它的子接口或者实现类初始化而初始化，只有程序首次使用特定接口的静态变量。才会导致该接口的初始化。
2.编译时常量
当一个类中变量被 final static 修饰成为静态常量时,我们再去主动调用该静态常量时,类的初始化的过程就是另一番的结果。

class Test1 {
    static final int cnt = 6 /3;
    static final int times = new Random().nextInt(100);
    static {
        System.out.println("Test Const ClassLoader!");
    }
}

public class ConstClassLoaderTest {
    public static void main(String[] args) {
        System.out.println("value=" + Test1.cnt);
    }
}

输出结果value=2,根据我们前面学习的知识点，应对类进行初始化，也就是说先输出静态代码块的内容再输出 value=2,因为cnt被final修饰，因此程序的运行结果会有些不一样。
对于静态常量cnt来说，java在编译阶段就可以确定该变量的具体数值因此不需要将该类进内存。而我们把这种静态变量叫做编译时常量。
当把代码修改成这样是程序的运行结果又会不一样。

public class ConstClassLoaderTest {
    public static void main(String[] args) {
        System.out.println("value=" + Test1.times);
    }
}

运行结果

Test Const ClassLoader!
value=41

对于静态常量times来说,java在编译阶段无法确定该变量的具体数值,需要在运行时才能确定，需要将该类加载进内存进行，初始化后确定该常量的具体数值。

3.只有当程序访问的静态变量或静态方法确实在当前类或当前接口中定义时，才可以认为是对类或接口的主动使用
如何理解这句话呢？我们还是看代码说话。

class Parent1 {
    static int cnt1 = 1;
    static {
        System.out.println("Parent1初始化!");
    }
    static void doSomeThing() {
        System.out.println("Parent1.doSomeThng()!");
    }
}

class Son1 extends Parent1 {
    static {
        System.out.println("Son1初始化！");
    }
}

public class TestClassLoader {
    public static void main(String[] args) {
        System.out.println(Son1.cnt1);
        Son1.doSomeThing();
    }
}

输出结果

Parent1初始化!
cnt1=1
Parent1.doSomeThng()!

为什么Son1的静态代码块没有执行呢？
因为cnt1是从父类继承下来的。并非在当前类(Son类)定义的静态成员/方法,因此Son的静态代码不会执行。

4.结果分析

看完了这些内容我们再分析一个刚开始的那个类的执行结果。

class Singleton {
    private static Singleton singleton = new Singleton(); //1
    public static int counter1;                           //2
    public static int counter2 = 0;                       //3

    private Singleton() {
        counter1++;
        counter2++;
    }

    public static Singleton getInstance() {
        return singleton;
    }
}

public class ClassLoaderClient {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
        System.out.println("counter1 = " + singleton.counter1);
        System.out.println("counter2 = " + singleton.counter2);
    }
}

由"java虚拟机会加载被声明为启动类的类"这条规则可以知道，JVM启动时首先会把ClassLoaderClient类加载进内存。
程序执行ClassLoaderClient.main()方法的第一条语句Sington.getInstance()获取Singtone类的一个唯一实例。但是getInstance()方法是静态方法，所以JVM会将Sington类加载进内存。会经历加载 => 连接 => 初始化
在[连接]中的[准备阶段]，会对Sington中静态变量!静态变量!静态变量!进行默认的初始化，赋值情况如下。

private static Singleton singleton = null;
public static int counter1 = 0;
public static int counter2 = 0;

然后在初始化阶段对程序进行默认初始化，此时代码中的第一行调用构造函数对Sington实例进行初始化。结果就是

public static int counter1 = 1;
public static int counter2 = 1;

最后执行第2，3行代码,counter1未对其进行赋值，所以保持其构造方法对它的赋值1,counter2 则进行了显式的赋值,此时 counter2为0

因此最终结果是。

// 输出结果
counter1 = 1
counter2 = 0

现在我们再来分析第二种情况，将第1行代码和第2，3行代码对调。

public static int counter1;                           
public static int counter2 = 0;                       
private static Singleton singleton = new Singleton();

其实前三步的结果是一样的就是从第四部开始有些不一样了。

在初始化阶段，类的初始化顺序和静态变量/静态代码的声明顺序是保持一致的，因此程序的执行流程是这样的。
1. counter1保持它的默认初始值0
2. counter2被显式的赋值为0（注意:是初始化阶段的赋值，并非准备阶段的默认值）
3. 调用new Singleton()构造方法对counter1赋值为1，counter2赋值1

因此最终结果是

// 输出结果
counter1 = 1
counter2 = 1

初识JVM-类加载器1