1、概述
类从被加载到虚拟机内存中开始,到卸载出内存为止,它的整个生命周期包括:加载(Loading)、验证(Verification)、准备(Preparation)、解析(Resolution)、初始化(Initialization)、使用(Useing)、卸载(Unloading)7个阶段。其中验证、准备和解析3个部分统称为连接(Linking),这7个阶段的发生顺序如图所示:
加载、验证、准备、初始化和卸载这5个阶段的顺序是确定的,类的加载过程,必须按照这种顺序按部就班地开始,而解析阶段则不一定:它在某些情况下可以在初始化阶段之后再开始,这是为了支持Java语言的运行时绑定(也称为动态绑定或晚期绑定) 。
对于初始化阶段,虚拟机规范则是严格规定了有且只有5种情况必须立即对类进行“初始化(执行<clinit>
方法阶段)”( 而加载、 验证、 准备自然需要在此之前开始):
- 遇到
new
、getstatic
、putstatic
或invokestatic
这4条字节码指令时,如果类没有进行过初始化,则需要先触发其初始化。 - 使用
java.lang.reflect
包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。 - 当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。
- 当虚拟机启动时,用户需要指定一个要执行的主类( 包含main()方法的那个类),虚拟机会先初始化这个主类。
- 当使用JDK 1.7的动态语言支持时,如果一个
java.lang.invoke.MethodHandle
实例最后的解析结果REF_getStatic
、REF_putStatic
、REF_invokeStatic
的方法句柄, 并且这个方法句柄所对应的类没有进行过初始化, 则需要先触发其初始化。
这五种情况称为对一个类进行主动引用。其余情况都不会触发初始化,称为被动引用。
2、主动引用
首先准备两个类用户测试其是否初始化。
SuperClass
/**
* @author lastwhisper
*/
public class SuperClass {
public static int value = 123;
static {
System.out.println("SuperClass static code init!");
}
public SuperClass() {
System.out.println("SuperClass constructor init! ");
}
public static int getValue() {
return value;
}
public static void setValue(int value) {
SuperClass.value = value;
}
}
SubClass 继承自SuperClass
/**
* @author lastwhisper
*/
public class SubClass extends SuperClass {
public static int subvalue = 456;
static {
System.out.println("SubClass static code init!");
}
public SubClass() {
System.out.println("SubClass constructor init! ");
}
public static int getSubvalue() {
return subvalue;
}
public static void setSubvalue(int subvalue) {
SubClass.subvalue = subvalue;
}
}
2.1 情景一
遇到new
、getstatic
、putstatic
或invokestatic
这4条字节码指令时,如果类没有进行过初始化,则需要先触发其初始化。
/**
* 主动引用触发初始化、演示一
* @author lastwhisper
*/
public class Initialization1 {
// 遇到new、getstatic、putstatic或invokestatic这4条字节码指令时,
// 如果类没有进行过初始化,则需要先触发其初始化。
public static void main(String[] args) {
// 1.new字节码指令
//SubClass subClass = new SubClass();
// 2.getstatic字节码指令
// 被final修饰、已在编译期把结果放入常量池的静态字段除外
//int subvalue = SubClass.subvalue;
// 3.setstatic字节码指令
// 被final修饰、已在编译期把结果放入常量池的静态字段除外
//SubClass.subvalue = 789;
// 4.invokestatic字节码指令
//SubClass.getSubvalue();
}
}
2.2 情景二
使用java.lang.reflect包的方法对类进行反射调用的时候,如果类没有进行过初始化,则需要先触发其初始化。
import java.lang.reflect.Constructor;
/**
* 主动引用触发初始化、演示二
* @author lastwhisper
*/
public class Initialization2 {
public static void main(String[] args) {
// 使用java.lang.reflect包的方法对类进行反射调用的时候,
// 如果类没有进行过初始化,则需要先触发其初始化。
try {
// 使用Class.forName();也行,不要使用对象.class。
Class<SubClass> clazz = SubClass.class;
Constructor<SubClass> constructor = clazz.getConstructor();
constructor.newInstance();
} catch (Exception e) {
e.printStackTrace();
}
}
}
2.3 情景三
当初始化一个类的时候,如果发现其父类还没有进行过初始化,则需要先触发其父类的初始化。
/**
* 主动引用触发初始化、演示三
* @author lastwhisper
*/
public class Initialization3 {
// 当初始化一个类的时候,如果发现其父类还没有进行过初始化,
// 则需要先触发其父类的初始化
public static void main(String[] args) {
// 在Initialization1的new指令和Initialization2的反射创建对象都有体现
SubClass subClass = new SubClass();
//初始化顺序
//SuperClass static code init! 首先初始化父类静态代码块
//SubClass static code init! 其次初始化自己的静态代码块
//SuperClass constructor init! 其次初始化父类的构造器
//SubClass constructor init! 其次初始化自己的构造器
}
}
2.4 情景四
当虚拟机启动时,用户需要指定一个要执行的主类( 包含main()方法的那个类),虚拟机会先初始化这个主类。
/**
* 主动引用触发初始化、演示四
* @author lastwhisper
*/
public class Initialization4 {
static {
System.out.println("Initialization4 static code init!");
}
public Initialization4() {
System.out.println("Initialization4 constructor init!");
}
public static void main(String[] args) {
// 当虚拟机启动时,用户需要指定一个要执行的主类(包含main()方法的那个类),虚拟机会先初始化这个主类。
}
}
2.5 情景五
当使用JDK 1.7的动态语言支持时,如果一个java.lang.invoke.MethodHandle
实例最后的解析结果REF_getStatic
、REF_putStatic
、REF_invokeStatic
的方法句柄, 并且这个方法句柄所对应的类没有进行过初始化, 则需要先触发其初始化。
首先创建一个MethodHandleClass类
/**
* @author lastwhisper
*/
public class MethodHandleClass {
static {
System.out.println("MethodHandleClass static code init!");
}
public MethodHandleClass() {
System.out.println("MethodHandleClass constructor init!");
}
// REF_invokeStatic
public static void testREF_invokeStatic(String str) {
System.out.println(str);
}
}
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
/**
* 主动引用触发初始化、演示五
* @author lastwhisper
*/
public class Initialization5 {
public static void main(String[] args) {
MethodHandles.Lookup lookup = MethodHandles.lookup();
try {
// REF_invokeStatic
MethodHandle testREF_invokeStatic = lookup.findStatic(MethodHandleClass.class, "testREF_invokeStatic", MethodType.methodType(void.class, String.class));
testREF_invokeStatic.invoke("啥也不干,打印一段话");
// REF_getStatic
// REF_putStatic
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (Throwable throwable) {
throwable.printStackTrace();
}
}
}
3、被动引用
被动引用不会触发类的初始化
3.1 情景一
通过子类调用父类的静态字段,只会触发子类的加载、父类的初始化,不会导致子类初始化:
import cn.lastwhisper.jvm.classloading.initiative.SubClass;
/**
* 被动使用类字段不触发初始化、演示一
* @author lastwhisper
*/
public class NotInitialization1 {
// 子类引用父类的静态字段,只会触发子类的加载、父类的初始化,不会导致子类初始化
// 是否要触发子类的加载和验证,在虚拟机规范中并未明确规定,这点取决于虚拟机的具体实现
// 对于Sun HotSpot虚拟机,可通过-XX:+TraceClassLoading参数观察到此操作会导致子类的加载
public static void main(String[] args) {
System.out.println(SubClass.value);
//[Loaded cn.lastwhisper.jvm.classloading.passive.SubClass from ...]
}
}
打印结果:子类并未初始化:
SuperClass static code init!
123
3.2 情景二
通过数组定义来引用类,不会触发此类的初始化
import cn.lastwhisper.jvm.classloading.initiative.SuperClass;
/**
* 被动使用类字段不触发初始化、演示二
* -XX:+TraceClassLoading
* @author lastwhisper
*/
public class NotInitialization2 {
public static void main(String[] args){
// 通过数组定义来引用类,不会触发此类的初始化
// 会触发L+全类名的初始化
SuperClass[] superClasses = new SuperClass[10];
}
}
3.3 情景三
常量在编译阶段会进行常量优化,将常量存入调用类的常量池中,本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化。
创建一个被static final修饰的类。
/**
* @author lastwhisper
*/
public class ConstClass {
public static final String HELLOWORLD = "hello world";
static {
System.out.println("ConstClass init!");
}
}
/**
* 被动使用类字段不触发初始化、演示三
* @author lastwhisper
*/
public class NotInitialization3 {
public static void main(String[] args) {
// 常量在编译阶段会进行常量优化,将常量存入**调用类**的常量池中,
// 本质上并没有直接引用到定义常量的类,因此不会触发定义常量的类的初始化。
System.out.println(ConstClass.HELLOWORLD);
// hello world
}
}
打印结果:
hello world // ConstClass类并未初始化