JVM——类初始化之主动引用和被动引用

背景

• 进入正题前先说下背景，本人最近在了解一些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高级特性与最佳实践》