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类初始化步骤

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

3.3.2类初始化的时机

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

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

1. 主动使用(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");

2. 被动使用
   除了以上六种情况，其他使用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);
    }
}

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

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

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

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

5. 最后执行第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