背景
- 进入正题前先说下背景，本人最近在了解一些JVM的知识，本文适合JVM初学者。本文完整代码链接见文末。
注：本着有目的学习的宗旨，本人在了解和涉猎JVM的过程中，对于一些JVM规范和指令大多是带过，远远达不到对JVM熟悉的地步。
-
OK，啥也不说，上来先丢两个名词先。在类的初始化过程中，对类的引用可分为两大类：
- 主动引用
- 被动引用
为了配合后续内容，先上四个非常简单的类，这几个类看不懂就别往下看了，因为你的Java基础还在来的路上：
public class SuperClass {
static {
System.out.println("SuperClass init!");
}
/**
* 类静态字段
*/
public static int value = 123;
}
public class SubClass extends SuperClass {
static {
System.out.println("SubClass init!");
}
}
public class ConstantsClass {
static {
System.out.println("ConstantsClass init!");
}
/**
* 类常量
*/
public static final int VALUE = 123;
}
public class MethodHandleClass {
static {
System.out.println("MethodHandleClass init");
}
public static void testMethodHandle(String str) {
System.out.println(str);
}
}
主动引用
- 类的初始化阶段，虚拟机规范严格规定了有且只有以下5种情况必须立即对类进行“初始化”，我们把这5种场景中的行为，称为对一个类进行主动引用。
1. 遇到new、getstatic、putstatic和invokestaic这4条字节码指令
-
遇到new、getstatic、putstatic和invokestaic这4条字节码指令时，如果类没有进行过初始化，则需要先触发类的初始化。
- new：创建类实例的指令（注意，与创建数组的指令不一样——newarray、anewarray、multianewarray）
- getstatic、putstatic：访问类字段的指令（static字段）
- invokestatic：调用类方法的指令（static方法）
public class Initialization1 {
public static void main(String[] args) {
// 遇到new字节码指令时，如果类没有进行过初始化，则需要先触发类的初始化
new SuperClass();
}
}
// 输出结果为
SuperClass init!
2. 反射调用
- 对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化
public class Initialization2 {
public static void main(String[] args) {
try {
// 对类进行反射调用的时候，如果类没有进行过初始化，则需要先触发其初始化
Class.forName("com.xpleemoon.classinit.SuperClass");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
// 输出结果为
SuperClass init!
3. 父类未初始化
- 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要触发其父类的初始化
public class Initialization3 {
public static void main(String[] args) {
// 当初始化一个类的时候，如果发现其父类还没有进行过初始化，则需要触发其父类的初始化
new SubClass();
}
}
// 输出结果为
SuperClass init!
SubClass init!
4. 执行的主类
- 当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类（包含main()方法的一个执行类）
public class Initialization4 {
static {
System.out.println("当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类");
}
public static void main(String[] args) {
}
}
// 输出结果为
当虚拟机启动时，用户需要指定一个要执行的主类，虚拟机会先初始化这个主类
5. 使用JDK 1.7 的动态语言支持
- 当使用JDK 1.7 的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的结果是REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化。
public class Initialization5 {
public static void main(String[] args) {
MethodHandles.Lookup lookup = MethodHandles.lookup();
try {
MethodHandle testMethodHandle = lookup.findStatic(MethodHandleClass.class, "testMethodHandle", MethodType.methodType(void.class, String.class));
try {
testMethodHandle.invoke("当使用JDK 1.7 的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的结果是\n" +
"REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化");
} catch (Throwable throwable) {
throwable.printStackTrace();
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
// 输出结果为
MethodHandleClass init
当使用JDK 1.7 的动态语言支持时，如果一个java.lang.invoke.MethodHandle实例最后的结果是
REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄对应的类没有进行过初始化，则需要先触发其初始化
被动引用
- 除主动引用（上述5中场景）之外，其他所有引用类的方式都不会触发初始化，这些其他类的引用方式称为被动引用。下面用三个例子来说明：
例子1——通过子类引用父类的静态字段，不会导致子类初始化
public class NotInitialization1 {
public static void main(String[] args) {
// 子类引用父类的静态字段，不会导致子类初始化
System.out.println(SubClass.value);
}
}
// 输出结果为
SuperClass init!
123
例子2——通过数组定义来引用类，不会触发此类的初始化
public class NotInitialization2 {
public static void main(String[] args) {
// 注意，这里的字节码指令是newarray而非new，那么这段代码的初始化就是类[SuperClass的初始化
SuperClass[] sca = new SuperClass[10];
}
}
// 输出结果为无
例子3——常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，因此不会触发
定义常量的类的初始化
public class NotInitialization3 {
public static void main(String[] args) {
// 常量在编译阶段会存入调用类的常量池中，本质上没有直接引用到定义常量的类，
// 因此不会触发定义常量的类的初始化
System.out.println(ConstantsClass.VALUE);
}
}
// 输出结果为
123
- 为了实验本文内容，请猛点代码仓库链接
- 参考书目——周志明《深入理解Java虚拟机——JVM高级特性与最佳实践》
