字节码执行引擎

运行时栈帧结构

用于支持虚拟机进行方法调用和方法执行背后的数据结构

栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息

每个栈帧的大小在编译期就已经确定（根据局部变量表操作数栈等）

局部变量表

用于存放方法参数和方法内部定义的局部变量，方法的Code属性max_locals数据项确定了局部变量表的最大容量

规范说到每个变量槽都应该能存放一个boolean、byte、char、short、int、float、reference或returnAddress类型的数据

虚拟机实现至少都应当能通过reference做两件事：

根据引用直接或间接地查找到对象在Java堆中的数据存放的起始地址或索引
根据引用直接或间接地查找到对象所属数据类型在方法区中的存储的类型信息

对于64位的数据类型，Java虚拟机会以高位对齐的方式为其分配两个连续的变量槽空间

局部变量表中的变量槽是可以重用的，但是这种重用会影响到垃圾回收，如果垃圾收集器发现变量表还存在某个变量的引用就不会轻易回收它：

byte[] bytes = new byte[1024 * 1024 * 128];
bytes = null; // 不加上这行 bytes不会在gc被调用时被回收
System.gc();

操作数栈

操作数栈的最大深度也在编译的时候被写入到Code属性的max_stacks数据项之中

用来支持各种指令操作

动态连接

每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用

方法返回地址

方法执行后有两种方式退出方法：

执行引擎遇到任意一个方法返回的字节码指令，这时候可能会有返回值传递给上层的方法调用者
方法执行的过程中遇到了异常，并且这个异常没有在方法体内得到妥善处理

方法退出时可能执行的操作有：恢复上层方法的局部变量表和操作数栈，把返回值（如果有的话）压入调用者栈帧的操作数栈中

附加信息

《Java虚拟机规范》允许虚拟机实现增加一些规范里没有描述的信息到栈帧之中，例如与调试、性能收集相关的信息

方法调用

方法调用是最普遍、最频繁的操作之一

方法调用的指令：

invokestatic：用于调用静态方法。
invokespecial：用于调用实例构造器<init>()方法、私有方法和父类中的方法
invokevirtual:用于调用所有的虚方法
invokeinterface:用于调用接口方法，会在运行时再确定一个实现该接口的对象
invokedynamic:先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法

只要能被invokestatic和invokespecial指令调用的方法，都可以在解析阶段中确定唯一的调用版本, 这些方法被称为非虚方法

public static void say(){
    System.out.println("hello world");
}
public static void main(String[] args) {
    say();
}

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: (0x0009) ACC_PUBLIC, ACC_STATIC
    Code:
      stack=0, locals=1, args_size=1
         0: invokestatic  #21                 // Method say:()V
         3: return
      LineNumberTable:
        line 12: 0
        line 13: 3

分派

静态类型：编译时能确定的类型

所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派。静态分派的最典型应用表现就是方法重载

编译过程中，编译器会暂时用符号引用来表示目标方法，这些符号引用存在类常量池中

static void f(Object obj){
    System.out.println("obj");
}
static void f(CharSequence seq){
    System.out.println("seq");
}
static void f(String str){
    System.out.println("str");
}
public static void main(String[] args) {
    Object obj = "str";
    CharSequence seq = "str";
    String str = "str";
    f(obj); // obj
    f(seq); // seq
    f(str); // str
}

动态分派

方法覆写的话会在运行时动态决定应该调用哪个方法

invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型，只有方法才会参与多态字段没有invokevirtual相关指令所以字段不会多态

单分派与多分派

静态多分派：根据参数来决定
动态单分派：根据被调用的对象决定

虚拟机动态分派的实现

为了性能 JVM不会频繁搜索类元数据而是使用了一个虚方法表：

屏幕截图 2020-10-29 145045

动态类型语言支持

invokedynamic指令，用以支持动态语言的方法调用，它将调用点（CallSite）抽象成一个 Java 类，并且将原本由 Java 虚拟机控制的方法调用以及方法链接暴露给了应用程序

动态类型语言：类型检查的主体过程是在运行期而不是编译期进行的

虚方法调用对性能的会影响 JVM 使用内联缓存加速动态绑定

java.lang.invoke

模拟invokedynamic:

                                              // 返回值类型  参数类型
MethodType methodType = MethodType.methodType(void.class, String.class);
Object obj = System.out;
MethodHandle methodHandle = MethodHandles.lookup()
        .findVirtual(obj.getClass(), "println", methodType).bindTo(obj);
methodHandle.invoke("hello world");

MethodHandle是在模拟字节码层次的方法调用反射API只能为Java服务使用invoke包可以用来开发动态语言

实战自己控制方法调用

static class GrandFather {
    void thinking() {
        System.out.println("i am grandfather");
    }
}
static class Father extends GrandFather {
    void thinking() {
        System.out.println("i am father");
    }
}

static class Son extends Father {
    void thinking() {
        // 在这里填入适当的代码（不能修改其他地方的代码）
        // 实现调用祖父类的thinking()方法，打印"i am grandfather"
        try {
            MethodType mt = MethodType.methodType(void.class);
            Field lookupImpl = MethodHandles.Lookup.class.getDeclaredField("IMPL_LOOKUP");
           lookupImpl.setAccessible(true);
           MethodHandle mh = ((MethodHandles.Lookup) lookupImpl.get(null)).findSpecial(GrandFather.class, "thinking", mt, GrandFather.class);
                try {
                    mh.invoke(this);
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }

        }
    }

执行引擎

解释执行

早期的JVM是通过解释字节码来执行的但后面也出现了编译为本地机器码的编译器所以现代的Java是拥有编译模式以及解释模式亦或者混合模式

基于栈

对于JVM来说基于栈移植容易实现容易

栈架构指令集的缺点在于速度稍慢

实战：分析一段简单的四则运算

public int calc(){
    int a = 100;
    int b = 200;
    int c = 300;
    return (a + b) * c;
}

public int calc();
    descriptor: ()I
    flags: (0x0001) ACC_PUBLIC
    Code:
      stack=2, locals=4, args_size=1
         0: bipush        100
         2: istore_1
         3: sipush        200
         6: istore_2
         7: sipush        300
        10: istore_3
        11: iload_1
        12: iload_2
        13: iadd
        14: iload_3
        15: imul
        16: ireturn
      LineNumberTable:
        line 9: 0
        line 10: 3
        line 11: 7
        line 12: 11

javap提示这段代码需要深度为2的操作数栈和4个变量槽的局部变量空间

1.Bipush指令的作用是将单字节的整型常量值（-128～127）推入操作数栈顶参数为100

屏幕截图 2020-10-29 153202