JVM 的类初始化机制

当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。

Loading, Linking, and Initialization

JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization。

下面分别介绍这三个过程：

Loading

Loading 过程主要工作是由ClassLoader完成。该过程具体包括三件事：

1. 根据类的全名，生成一份二进制字节码来表示该类

2. 将二进制的字节码解析成方法区对应的数据结构

3. 最后生成一 Class 对象的实例来表示该类

JVM 中除了最顶层的Boostrap ClassLoader是用 C/C++ 实现外，其余类加载器均由 Java 实现，我们可以用getClassLoader方法来获取当前类的类加载器：

public class ClassLoaderDemo {
    public static void main(String[] args) {
        System.out.println(ClassLoaderDemo.class.getClassLoader());
    }
}

# sun.misc.Launcher$AppClassLoader@30a4effe
# AppClassLoader 也就是上图中的 System Class Loader

此外，我们在启动java传入-verbose:class来查看加载的类有那些。

java -verbose:class ClassLoaderDemo

[Opened /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Object from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.io.Serializable from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Comparable from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.CharSequence from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]

....
....

[Loaded java.security.BasicPermissionCollection from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded ClassLoaderDemo from file:/Users/liujiacai/codes/IdeaProjects/mysql-test/target/classes/]
[Loaded sun.launcher.LauncherHelper$FXHelper from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Class$MethodArray from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Void from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
sun.misc.Launcher$AppClassLoader@2a139a55
[Loaded java.lang.Shutdown from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]
[Loaded java.lang.Shutdown$Lock from /Library/Java/JavaVirtualMachines/jdk1.8.0_112.jdk/Contents/Home/jre/lib/rt.jar]

Linking

Verification

Verification 主要是保证类符合 Java 语法规范，确保不会影响 JVM 的运行。包括但不限于以下事项：

• bytecode 的完整性（integrity）

• 检查final类没有被继承，final方法没有被覆盖

• 确保没有不兼容的方法签名

Preparation

在一个类已经被load并且通过verification后，就进入到preparation阶段。在这个阶段，JVM 会为类的成员变量分配内存空间并且赋予默认初始值，需要注意的是这个阶段不会执行任何代码，而只是根据变量类型决定初始值。如果不进行默认初始化，分配的空间的值是随机的，有点类型c语言中的野指针问题。

Type    Initial Value
int    0
long    0L
short    (short) 0
char    '\u0000'
byte    (byte) 0
boolean    false
reference    null
float    0.0f
double    0.0d

在这个阶段，JVM 也可能会为有助于提高程序性能的数据结构分配内存，常见的一个称为method table的数据结构，它包含了指向所有类方法（也包括也从父类继承的方法）的指针，这样再调用父类方法时就不用再去搜索了。

Resolution

Resolution 阶段主要工作是确认类、接口、属性和方法在类run-time constant pool的位置，并且把这些符号引用（symbolic references）替换为直接引用（direct references）。

locating classes, interfaces, fields, and methods referenced symbolically from a type's constant pool, and replacing those symbolic references with direct references.

这个过程不是必须的，也可以发生在第一次使用某个符号引用时。

Initialization

经过了上面的load、link后，第一次 主动调用某类的最后一步是Initialization，这个过程会去按照代码书写顺序进行初始化，这个阶段会去真正执行代码，注意包括：代码块（static与static）、构造函数、变量显式赋值。如果一个类有父类，会先去执行父类的initialization阶段，然后在执行自己的。

上面这段话有两个关键词：第一次与主动调用。第一次是说只在第一次时才会有初始化过程，以后就不需要了，可以理解为每个类有且仅有一次初始化的机会。那么什么是主动调用呢？
JVM 规定了以下六种情况为主动调用，其余的皆为被动调用：

1. 一个类的实例被创建（new操作、反射、cloning，反序列化）

2. 调用类的static方法

3. 使用或对类/接口的static属性进行赋值时（这不包括final的与在编译期确定的常量表达式）

4. 当调用 API 中的某些反射方法时

5. 子类被初始化

6. 被设定为 JVM 启动时的启动类（具有main方法的类）

本文后面会给出一个示例用于说明主动调用的被动调用区别。

在这个阶段，执行代码的顺序遵循以下两个原则：

1. 有static先初始化static，然后是非static的

2. 显式初始化，构造块初始化，最后调用构造函数进行初始化

示例

属性在不同时期的赋值

class Singleton {

    private static Singleton mInstance = new Singleton();// 位置1
    public static int counter1;
    public static int counter2 = 0;

//    private static Singleton mInstance = new Singleton();// 位置2

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

    public static Singleton getInstantce() {
        return mInstance;
    }
}

public class InitDemo {

    public static void main(String[] args) {

        Singleton singleton = Singleton.getInstantce();
        System.out.println("counter1: " + singleton.counter1);
        System.out.println("counter2: " + singleton.counter2);
    }
}

当mInstance在位置1时，打印出

counter1: 1
counter2: 0

当mInstance在位置2时，打印出

counter1: 1
counter2: 1

Singleton中的三个属性在Preparation阶段会根据类型赋予默认值，在Initialization阶段会根据显示赋值的表达式再次进行赋值（按顺序自上而下执行）。根据这两点，就不难理解上面的结果了。

主动调用 vs. 被动调用

class NewParent {

    static int hoursOfSleep = (int) (Math.random() * 3.0);

    static {
        System.out.println("NewParent was initialized.");
    }
}

class NewbornBaby extends NewParent {

    static int hoursOfCrying = 6 + (int) (Math.random() * 2.0);

    static {
        System.out.println("NewbornBaby was initialized.");
    }
}

public class ActiveUsageDemo {

    // Invoking main() is an active use of ActiveUsageDemo
    public static void main(String[] args) {

        // Using hoursOfSleep is an active use of NewParent,
        // but a passive use of NewbornBaby
        System.out.println(NewbornBaby.hoursOfSleep);
    }

    static {
        System.out.println("ActiveUsageDemo was initialized.");
    }
}

上面的程序最终输出：

ActiveUsageDemo was initialized.
NewParent was initialized.
1

之所以没有输出NewbornBaby was initialized.是因为没有主动去调用NewbornBaby，如果把打印的内容改为NewbornBaby.hoursOfCrying 那么这时就是主动调用NewbornBaby了，相应的语句也会打印出来。

首次主动调用才会初始化

public class Alibaba {

    public static int k = 0;
    public static Alibaba t1 = new Alibaba("t1");
    public static Alibaba t2 = new Alibaba("t2");
    public static int i = print("i");
    public static int n = 99;
    private int a = 0;
    public int j = print("j");
    {
        print("构造块");
    }
    static {
        print("静态块");
    }

    public Alibaba(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;
    }

    public static int print(String str) {
        System.out.println((++k) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }

    public static void main(String args[]) {
        Alibaba t = new Alibaba("init");
    }
}

上面这个例子是阿里巴巴在14年的校招附加题，我当时看到这个题，就觉得与阿里无缘了。囧

1:j   i=0    n=0
2:构造块   i=1    n=1
3:t1   i=2    n=2
4:j   i=3    n=3
5:构造块   i=4    n=4
6:t2   i=5    n=5
7:i   i=6    n=6
8:静态块   i=7    n=99
9:j   i=8    n=100
10:构造块   i=9    n=101
11:init   i=10    n=102

上面是程序的输出结果，下面我来一行行分析之。

1. 由于Alibaba是 JVM 的启动类，属于主动调用，所以会依此进行 loading、linking、initialization 三个过程。

2. 经过 loading与 linking 阶段后，所有的属性都有了默认值，然后进入最后的 initialization 阶段。

3. 在 initialization 阶段，先对 static 属性赋值，然后在非 static 的。k 第一个显式赋值为 0 。

4. 接下来是t1属性，由于这时Alibaba这个类已经处于 initialization 阶段，static 变量无需再次初始化了，所以忽略 static 属性的赋值，只对非 static 的属性进行赋值，所有有了开始的：

       1:j   i=0    n=0
       2:构造块   i=1    n=1
       3:t1   i=2    n=2
   

5. 接着对t2进行赋值，过程与t1相同

       4:j   i=3    n=3
       5:构造块   i=4    n=4
       6:t2   i=5    n=5
   

6. 之后到了 static 的 i 与 n：

       7:i   i=6    n=6
   

7. 到现在为止，所有的static的成员变量已经赋值完成，接下来就到了 static 代码块

       8:静态块   i=7    n=99
   

8. 至此，所有的 static 部分赋值完毕，接下来是非 static 的 j

       9:j   i=8    n=100
   

9. 所有属性都赋值完毕，最后是构造块与构造函数

       10:构造块   i=9    n=101
       11:init   i=10    n=102
   

经过上面这9步，Alibaba这个类的初始化过程就算完成了。这里面比较容易出错的是第3步，认为会再次初始化 static 变量或代码块。而实际上是没必要，否则会出现多次初始化的情况。

希望大家能多思考思考这个例子的结果，加深这三个过程的理解。

总结

经过最后这三个例子，相信大家对 JVM 对类加载机制都有了更深的理解，如果大家还是有疑问，欢迎留意讨论。

参考

• Java Virtual Machine Specification Chapter 5

• Chapter 7 of Inside the Java Virtual Machine

• JVM Internals

• What kind of method is Constructor, static or non static?

• Understanding the Java ClassLoader