JVM字节码执行引擎思惟导图

时间 2019-12-05

标签 jvm 字节执行引擎思惟栏目 Java 繁體版

原文原文链接

本文参考自来自周志明《深刻理解Java虚拟机（第2版）》，拓展内容建议读者能够阅读下这本书。

文字版以下：java

运行时栈帧结构

局部变量表

须要多少大小的局部变量表已写入到class字节码方法的Code属性的max_locals属性中
一个存储单位称为一个Slot(32位)缓存
- 为了让全部数据类型的局部变量都可以存储到局部变量表中而设定了定长的Slot长度ide
  - 32位之内的数据类型(boolean | byte | char | short | int | float | reference | returnAddress)变量使用1个Slot存储
  - 32位以上的数据类型(long | double)变量使用2个Slot存储，会以高位对齐的方式进行存储
局部变量第0位Slot优化
- 实例方法的局部变量表的第0位存储的是用于传递方法所属对象实例的this引用
- 静态方法的局部变量表没有这个this引用
Slot重用：离开了做用域的局部变量占用的Slot能够被重用this
- 对垃圾回收的影响：离开了做用域的局部变量所在的Slot只有在真的不存在对原有局部变量的引用时，GC才会回收相应的对象实例spa
  - 花括号内的局部变量a在花括号外出了做用域，直接GC也不会回收a，就是因为这时仍是存在Slot对a的引用
  - 花括号内的局部变量a在花括号外出了做用域，花括号外再有一个局部变量赋值致使Slot被重用了，GC就会回收a，就是因为Slot对a的引用没有了
局部变量和类字段的区别code
- 生命周期不一样对象
  - 类字段的生命周期是类的生命周期
  - 局部变量的生命周期是方法中变量的生命周期
- 赋初值不一样继承
  - 类字段会在类加载的准备阶段赋零值，再会在类加载的初始化赋初值
  - 局部变量的初值若是没有手动赋值的话是没有的，编译阶段即会报出未初始化就使用的错误
reference类型索引
- 能够从reference类型变量中直接或间接地查找到对象在Java堆中存放的起始地址索引
- 能够从reference类型变量中直接或间接地查找到对象所属类型在方法区中的类的存储信息

操做数栈

须要多大的栈深度已写入到class字节码方法的Code属性的max_stacks属性中，任什么时候候栈容量都不能超过最大栈深度
一个存储单位称为一个栈容量
- 为了让全部数据类型的局部变量都可以存储到栈中而设定了定长的栈容量
  - 32位之内的数据类型(boolean | byte | char | short | int | float | reference | returnAddress)变量使用栈容量为1
  - 32位以上的数据类型(long | double)变量使用栈容量为2

动态连接

为了知足方法指令的运行时解析
- 静态解析：把方法调用指令中的符号引用在类加载或首次运行时转换为直接引用，即这些方法引用是静态可肯定的引用
- 动态连接：把方法调用指令中的符号引用在运行时才转换为直接引用，即这些方法引用是动态运行时才可肯定的

方法返回地址

退出方法的方式
- 正常返回出口：执行到返回指令字节码的时候会将方法返回值传递给上层的方法调用者
- 异常完成出口：方法执行遭遇异常，如JVM内部异常或者athrow字节码指令，且在异常表中未找到匹配处理器致使退出，不会给上层的方法调用者任何返回值
退出方法执行的操做
- 恢复上层方法的局部变量表
- 把返回值压入调用者栈帧的操做数栈
- 调整PC计数器的值指向方法调用指令的后一条指令

附加信息

方法调用

方法执行的步骤

方法编译：将源码编译称class字节码中的符号引用
方法调用：将class字节码中的符号引用解析成直接引用
方法执行：执行解析出的直接引用指向地址的方法

虚方法和非虚方法

非虚方法：在类加载的时候就能够将符号引用解析为直接引用的方法，即不存在因覆盖而产生多版本的方法
- 静态方法
- 实例构造器<init>方法
- 私有方法
- 父类方法
- final方法
虚方法：在类加载的时候有可能没法肯定符号引用能够解析为哪一个直接引用的方法
- 因覆盖父类方法而出现的多版本方法没法在类加载时就肯定方法的直接引用
- 目前没有产生覆盖的方法虽然不存在多版本可是也归为了虚方法，由于它可能会被新类覆盖方法

5种方法调用字节码

invokestatic
- 静态方法
invokespecial
- 实例构造器<init>方法
- 私有方法
- 父类方法
invokevirtual
- final方法
- 虚方法
invokeinterface
- 接口方法，会在运行时再肯定实现接口的对象
invokedynamic
- 运行时动态解析出调用点限定符所引用的方法再执行

分派 Dispatch

静态分派 Method Overload Resolution
- 编译期便可肯定方法的版本
- 由编译器直接解析来完成方法版本的断定，不须要虚拟机介入
- 典型应用是方法重载 Overload
  - 重载：方法签名不一样（方法名相同、参数列表不一样）
  - 编译阶段就会将重载方法调用解析为 invokevirtual 选择的方法版本的符号引用
  - 方法m(Q)重载了方法m(P)，编译器解析名为m的方法时会根据其参数p的静态类型(即外观类型或者直接类型)来选择方法的版本
  - 若是参数是无显式的静态类型的字面量，那么编译期会最大可能地去推断字面量最贴近的参数类型。如print(‘a’)解析为重载的方法版本print(char) print(int)时会优先推断字面量类型为char选择前者，若是没有前者定义的话才会选择后者
动态分派
- 运行期才可肯定方法的版本
- 由虚拟机来完成方法版本的断定
- 典型应用是方法重写 Override
  - 重写：方法签名相同（方法名相同、参数列表相同）
  - 编译阶段就会将重写方法调用解析为 invokevirtual 选择的方法版本的符号引用
  - 类B的方法m(P)重写了B所继承的类A的方法m(P)，实际类型为B，A b = new B()，即静态类型为A的对象b，发生了方法调用b.m(p)
    - 编译期：编译器将b.m(p)编译成了invokevirtual A.m
    - 运行期
      - 找到操做数栈顶的第一个元素指向对象即b的实际类型，也就是B
      - 在B中寻找与invokevirtual调用的方法符号引用名称和签名一致的方法
        
        找到了的话说明实际类型B中就有了这个方法m(P)，而后断定该方法是否知足访问权限
        
        知足：将调用的方法符号引用替换为该方法的直接引用
        
        不知足：抛出java.lang.illegalAccessError异常
        
        没找到
        
        在B的父类中自下向上寻找与invokevirtual调用的方法符号引用名称和签名一致的方法
        
        找到了的话说明实际类型B的父类中有这个方法m(P)，而后断定该方法是否知足访问权限
        
        知足：将调用的方法符号引用替换为该方法的直接引用
        
        不知足：抛出java.lang.illegalAccessError异常
        
        始终没找到：抛出java.lang.AbstractMethodError异常

方法宗量：方法的接收者(全部者)和参数

单分派：根据单个方法宗量进行方法选择
- 静态阶段(编译期)的选择过程是依据方法的接收者和方法的参数两个总量来选择的，所以静态阶段多分派
多分派：根据多个方法宗量进行方法选择
- 动态阶段(运行时)的选择过程是依据方法的接收者来选择的，所以动态阶段单分派

虚拟机动态分派的实现

搜索虚方法的合适版本：代价太大
稳定优化手段：虚方法表 提早记录避免运行时搜索的手段
- 父类类加载时准备虚方法表，虚方法表将每一个虚方法的表中索引指向方法区中的类信息的方法实际地址
- 子类类加载时准备虚方法表，虚方法表将重写的方法指向子类在方法区中类信息的方法实际地址，而未重写的方法仍旧指向其父类方法区中的类信息的方法实际地址
- 调用虚方法时能够直接获取到这个方法的实际地址而免去了搜索过程
非稳定的激进优化手段
- 内联缓存
- 基于“类型继承关系分析”技术的守护内联

基于栈的解释器的执行过程

下面来看一下静态分派和动态分派的例子

静态分派，使用方法重载做为例子看一下编译期的结果：

源码定义了继承了Human的Man和Woman，关键在于看一下编译器将test.sayHi(human);、test.sayHi(woman);、test.sayHi(man);编译成了什么，也就是说静态阶段编译器重载方法的方法分派是什么样的。

class Human{

}

class Man extends Human{

}

class Woman extends Human{

}

public class DispatchTest {

    public void sayHi(Human human){
        System.out.println("Hi human");
    }

    public void sayHi(Man man){
        System.out.println("Hi man");
    }

    public void sayHi(Woman woman){
        System.out.println("Hi woman");
    }

    public static void main(String[] args) {
        Human human = new Human();
        Human man = new Man();
        Human woman = new Woman();
        DispatchTest test = new DispatchTest();
        test.sayHi(human);
        test.sayHi(woman);
        test.sayHi(man);
    }
}

javap获取到的class字节码解释：

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=5, args_size=1
         0: new           #7                  // class Human
         3: dup
         4: invokespecial #8                  // Method Human."<init>":()V
         7: astore_1
         8: new           #9                  // class Man
        11: dup
        12: invokespecial #10                 // Method Man."<init>":()V
        15: astore_2
        16: new           #11                 // class Woman
        19: dup
        20: invokespecial #12                 // Method Woman."<init>":()V
        23: astore_3
        24: new           #13                 // class DispatchTest
        27: dup
        28: invokespecial #14                 // Method "<init>":()V
        31: astore        4
        33: aload         4
        35: aload_1
        36: invokevirtual #15                 // Method sayHi:(LHuman;)V
        39: aload         4
        41: aload_3
        42: invokevirtual #15                 // Method sayHi:(LHuman;)V
        45: aload         4
        47: aload_2
        48: invokevirtual #15                 // Method sayHi:(LHuman;)V
        51: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      52     0  args   [Ljava/lang/String;
            8      44     1 human   LHuman;
           16      36     2   man   LHuman;
           24      28     3 woman   LHuman;
           33      19     4  test   LDispatchTest;

这段字节码的表义很清晰，就是建立了类型为Human的Man和Woman的三个类的对象实例，而后在执行test.sayHi(human);、test.sayHi(woman);、test.sayHi(man);的时候都将其编译成了调用方法sayHi:(LHuman;)V，即参数类型是Human的sayHi方法。从这里咱们能够看出来实际上静态编译重载方法的时候的只会使用方法参数的静态类型指定的方法，而实际类型因为在运行时可能会发生变化，没有办法在编译期得到其实际类型，所以采用了这种方式直接肯定方法的分派结果。

动态分派，使用方法重写做为例子看一下编译期的结果：

源码定义了继承了Human的Man和Woman，关键在于看一下编译器将man.sayHi();、woman.sayHi();编译成了什么，也就是说静态阶段编译器对重写方法的方法分派是什么样的。

abstract class Human{
    protected abstract void sayHi();
}

class Man extends Human{

    @Override
    protected void sayHi() {
        System.out.println("Hi man");
    }
}

class Woman extends Human{

    @Override
    protected void sayHi() {
        System.out.println("Hi woman");
    }
}

public class DispatchTest {

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();
        DispatchTest test = new DispatchTest();
        man.sayHi();
        woman.sayHi();
    }
}

javap获取到的class字节码解释：

public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=4, args_size=1
         0: new           #2                  // class Man
         3: dup
         4: invokespecial #3                  // Method Man."<init>":()V
         7: astore_1
         8: new           #4                  // class Woman
        11: dup
        12: invokespecial #5                  // Method Woman."<init>":()V
        15: astore_2
        16: new           #6                  // class DispatchTest
        19: dup
        20: invokespecial #7                  // Method "<init>":()V
        23: astore_3
        24: aload_1
        25: invokevirtual #8                  // Method Human.sayHi:()V
        28: aload_2
        29: invokevirtual #8                  // Method Human.sayHi:()V
        32: return
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      33     0  args   [Ljava/lang/String;
            8      25     1   man   LHuman;
           16      17     2 woman   LHuman;
           24       9     3  test   LDispatchTest;

这段字节码建立了类型为Man和Woman的两个类的对象实例，而后在执行man.sayHi();、woman.sayHi();的时候都将其编译成了调用方法Human.sayHi:()V，即Human类型的sayHi方法。从这里咱们能够看出来实际上静态编译重写方法的时候的只会使用实例对象的静态类型的方法，而实际类型因为在运行时可能会发生变化，没有办法在编译期得到其实际类型，所以采用了这种方式直接肯定方法的分派结果。可是在运行时会去获取这个实例对象的实际类型，而后看这个实际类型是否认了名称和限定符知足的方法，若是有就会选择分派到这个方法上。这就是运行时动态分派产生的影响，这种选择在编译器是看不出来的。