JVM学习笔记5——虚拟机字节码指令与执行引擎

r囧r小猫 2022-05-30 11:14 252阅读 0赞

*  虚拟机字节码执行引擎
    
     *  字节码指令
        
         *  字节码指令分类
     *  运行时栈帧结构
        
         *  局部变量表
         *  操作数栈
         *  动态连接
         *  方法返回地址
         *  附加信息
     *  基于栈的字节码解释执行引擎
        
         *  基于栈的指令集与基于寄存器的指令集
         *  基于栈的解释器执行过程

# 虚拟机字节码执行引擎 #

## 字节码指令 ##

Java虚拟机的指令由一个字节长度的、代表着某种特定操作含义的数字（称为操作码，Opcode）以及跟随其后的零至多个代表此操作所需参数（称为操作数，Operands）而构成。由于Java虚拟机采用面向操作数栈而不是寄存器的架构，所以大多数的指令都不包含操作数，只有一个操作码。

在Java虚拟机的指令集中，大多数的指令都包含了其操作所对应的数据类型信息。例如，iload指令用于从局部变量表中加载int型的数据到操作数栈中，而fload指令加载的则是float类型的数据。这两条指令的操作在虚拟机内部可能会是由同一段代码来实现的，但在Class文件中它们必须拥有各自独立的操作码。

### 字节码指令分类 ###

*  加载和存储指令
 *  运算指令
 *  类型转换指令
 *  对象创建与访问指令
 *  操作数栈管理指令
 *  控制转移指令
 *  方法调用和返回指令
 *  异常处理指令
 *  同步指令

以EmployeeV1为例，javap反编译出字节码，然后逐句解释。

public class EmployeeV1 { 
    
    
        private String name;
        private int age;
    
        public EmployeeV1(String name, int age) {
            this.name = name;
            this.age = age;        
        }    
    
        public void setName(String name) {
            this.name = name;
        }
        public void setAge(int age){
            this.age = age;
        }
        public void sayHello() {        
            System.out.println("Hello , this is class Employee ");      
        }
        public static void main(String[] args){
            EmployeeV1 p = new EmployeeV1("Andy",29);
            p.sayHello();    
    
        }
    }

主要看main和 两个函数

main函数

0: new           #7                  // class EmployeeV1
             3: dup           
             4: ldc           #8                  // String Andy
             6: bipush        29
             8: invokespecial #9                  // Method "<init>":(Ljava/lang/String;I)V
            11: astore_1      
            12: aload_1       
            13: invokevirtual #10                 // Method sayHello:()V
            16: return

new  indexbyte1, indexbyte2
    操作：创建一个对象
    （indexbyte1 << 8）| indexbyte2 得到一个指向常量池的索引
    BB 00 07  ->  new      #7                 
    对应的类是 EmployeeV1
    在堆中为对象EmployeeV1开辟内存空间，把对象的引用压入当前函数栈帧的操作数栈
    
    字节码指令： dup
    操作：复制操作数栈栈顶的值，并压入到栈顶 
    
    ldc index
    操作：从运行时常量池中提取数据压入栈中
    Ldc #8
        #8在常量池的值为字符串”Andy”
    值的注意的是， 这个字符串在.class文件中已经存在了
    此时栈顶是字符串”Andy”
    
    Bipush byte 
    操作：将 byte 带符号扩展为一个 int 类型的值 value，然后将 value 压入到操作数栈中。
    Bipush 29
    注意：29不是对常量池的引用
    而是一个实际的数（立即数）
    此时栈顶是29
    
    invokespecial  indexbyte1 indexbyte2 
    操作：对一个对象进行初始化， 父类的初始化， 调用私有方法
    （indexbyte1 << 8）| indexbyte2 得到一个指向常量池的索引
    Invokespecial #9
    "<init>":(Ljava/lang/String;I)V
    形成<init>函数的新栈帧
    
    astore_n
    操作：将栈顶的reference 类型数据保存到 局部变量表 中 
    astore_0
    astore_1
    astore_2
    astore_3
    
    aload_n
    操作：从局部变量表加载一个 reference 类型值到操作数栈中 
    aload_0
    aload_1
    aload_2
    aload_3
    
    Invokevirtual indexbyte1 indexbyte2
    操作：调用实例方法，依据实例的类型进行分派 (多态！！)
    （indexbyte1 << 8）| indexbyte2 得到一个指向常量池的索引
    invokevirtual #10
    sayHello:    ()V
    也需要形成新的栈帧
    
    return 
    操作：方法返回，从当前函数栈帧退出，  无返回值

函数

0: aload_0       
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: aload_0       
             5: aload_1       
             6: putfield      #2                  // Field name:Ljava/lang/String;
             9: aload_0       
            10: iload_2       
            11: putfield      #3                  // Field age:I
            14: return

字节码指令 ： 2A
    助记符： aload_0
    操作：从局部变量表中把index为0的reference 类型值加载到到操作数栈中
    
    字节码指令 ： 2B
    助记符： aload_1
    操作：从局部变量表中把index为1的reference 类型值加载到到操作数栈中
    
    字节码指令 ： B5  indexbyte1  indexbyte2 
    助记符： putfield
    操作：给一个对象的字段赋值
    （indexbyte1 << 8）| indexbyte2 得到一个指向常量池的索引 ，  这个索引应该是一个字段
    例子： B5 00 0F 
    putfield  #15                 
    对应的字段是 name:Ljava/lang/String;
    
    字节码指令 ： 2A
    助记符： aload_0
    操作：从局部变量表中把index为0的reference的值加载到到操作数栈中
    
    字节码指令 ： 1C
    助记符： iload_2
    操作：从局部变量表中把index为2的int类型的值加载到到操作数栈中

## 运行时栈帧结构 ##

栈帧（Stack Frame）是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区中的虚拟机栈（Virtual Machine Stack）的栈元素。栈帧存储了方法的局部变量表、操作数栈、动态连接和方法返回地址等信息。每一个方法从调用开始至执行完成的过程，都对应着一个栈帧在虚拟机栈里面从入栈到出栈的过程。

每一个栈帧都包括了局部变量表、操作数栈、动态连接、方法返回地址和一些额外的附加信息。在编译程序代码的时候，栈帧中需要多大的局部变量表，多深的操作数栈都已经完全确定了，并且写入到方法表的Code属性之中，因此一个栈帧需要分配多少内存，不会受到程序运行期变量数据的影响，而仅仅取决于具体的虚拟机实现。

一个线程中的方法调用链可能会很长，很多方法都同时处于执行状态。对于执行引擎来说，在活动线程中，只有位于栈顶的栈帧才是有效的，称为当前栈帧（Current Stack Frame），与这个栈帧相关联的方法称为当前方法（Current Method）。执行引擎运行的所有字节码指令都只针对当前栈帧进行操作

![这里写图片描述][70]

### 局部变量表 ###

局部变量表（Local Variable Table）是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。在Java程序编译为Class文件时，就在方法的Code属性的max\_locals数据项中确定了该方法所需要分配的局部变量表的最大容量。

局部变量表的容量以变量槽（Variable Slot，下称Slot）为最小单位

在方法执行时，虚拟机是使用局部变量表完成参数值到参数变量列表的传递过程的，如果执行的是实例方法（非static的方法），那局部变量表中第0位索引的Slot默认是用于传递方法所属对象实例的引用，在方法中可以通过关键字“this”来访问到这个隐含的参数。

为了尽可能节省栈帧空间，局部变量表中的Slot是可以重用的。在某些情况下，Slot的复用会直接影响到系统的垃圾收集行为。

### 操作数栈 ###

操作数栈（Operand Stack）也常称为操作栈，它是一个后入先出（Last In First Out,LIFO）栈。同局部变量表一样，操作数栈的最大深度也在编译的时候写入到Code属性的max\_stacks数据项中。

当一个方法刚刚开始执行的时候，这个方法的操作数栈是空的，在方法的执行过程中，会有各种字节码指令往操作数栈中写入和提取内容，也就是出栈/入栈操作。例如，在做算术运算的时候是通过操作数栈来进行的，又或者在调用其他方法的时候是通过操作数栈来进行参数传递的。

举个例子，整数加法的字节码指令iadd在运行的时候操作数栈中最接近栈顶的两个元素已经存入了两个int型的数值，当执行这个指令时，会将这两个int值出栈并相加，然后将相加的结果入栈。

操作数栈中元素的数据类型必须与字节码指令的序列严格匹配。

另外，在概念模型中，两个栈帧作为虚拟机栈的元素，是完全相互独立的。但在大多虚拟机的实现里都会做一些优化处理，令两个栈帧出现一部分重叠。让下面栈帧的部分操作数栈与上面栈帧的部分局部变量表重叠在一起，这样在进行方法调用时就可以共用一部分数据，无须进行额外的参数复制传递。

Java虚拟机的解释执行引擎称为“基于栈的执行引擎”，其中所指的“栈”就是操作数栈。

### 动态连接 ###

每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程中的动态连接（Dynamic Linking）。通过第6章的讲解，我们知道Class文件的常量池中存有大量的符号引用，字节码中的方法调用指令就以常量池中指向方法的符号引用作为参数。这些符号引用一部分会在类加载阶段或者第一次使用的时候就转化为直接引用，这种转化称为静态解析。另外一部分将在每一次运行期间转化为直接引用，这部分称为动态连接。

### 方法返回地址 ###

当一个方法开始执行后，只有两种方式可以退出这个方法。第一种方式是执行引擎遇到任意一个方法返回的字节码指令，这时候可能会有返回值传递给上层的方法调用者（调用当前方法的方法称为调用者），是否有返回值和返回值的类型将根据遇到何种方法返回指令来决定，这种退出方法的方式称为正常完成出口（Normal Method Invocation Completion）。

另外一种退出方式是，在方法执行过程中遇到了异常，并且这个异常没有在方法体内得到处理，无论是Java虚拟机内部产生的异常，还是代码中使用athrow字节码指令产生的异常，只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，这种退出方法的方式称为异常完成出口（Abrupt Method Invocation Completion）。一个方法使用异常完成出口的方式退出，是不会给它的上层调用者产生任何返回值的。

无论采用何种退出方式，在方法退出之后，都需要返回到方法被调用的位置，程序才能继续执行，方法返回时可能需要在栈帧中保存一些信息，用来帮助恢复它的上层方法的执行状态。一般来说，方法正常退出时，调用者的PC计数器的值可以作为返回地址，栈帧中很可能会保存这个计数器值。而方法异常退出时，返回地址是要通过异常处理器表来确定的，栈帧中一般不会保存这部分信息。

方法退出的过程实际上就等同于把当前栈帧出栈，因此退出时可能执行的操作有：恢复上层方法的局部变量表和操作数栈，把返回值（如果有的话）压入调用者栈帧的操作数栈中，调整PC计数器的值以指向方法调用指令后面的一条指令等。

### 附加信息 ###

虚拟机规范允许具体的虚拟机实现增加一些规范里没有描述的信息到栈帧之中，例如与调试相关的信息，这部分信息完全取决于具体的虚拟机实现，这里不再详述。在实际开发中，一般会把动态连接、方法返回地址与其他附加信息全部归为一类，称为栈帧信息。

## 基于栈的字节码解释执行引擎 ##

### 基于栈的指令集与基于寄存器的指令集 ###

Java编译器输出的指令流，基本上\[1\]是一种基于栈的指令集架构（Instruction Set Architecture,ISA），指令流中的指令大部分都是零地址指令，它们依赖操作数栈进行工作。与之相对的另外一套常用的指令集架构是基于寄存器的指令集，最典型的就是x86的二地址指令集，说得通俗一些，就是现在我们主流PC机中直接支持的指令集架构，这些指令依赖寄存器进行工作。那么，基于栈的指令集与基于寄存器的指令集这两者之间有什么不同呢？

举个最简单的例子，分别使用这两种指令集计算“1+1”的结果，基于栈的指令集会是这样子的：

iconst_1
        iconst_1
        iadd
        istore_0

两条iconst\_1指令连续把两个常量1压入栈后，iadd指令把栈顶的两个值出栈、相加，然后把结果放回栈顶，最后istore\_0把栈顶的值放到局部变量表的第0个Slot中。

如果基于寄存器，那程序可能会是这个样子：

mov eax，1
        add eax，1

mov指令把EAX寄存器的值设为1，然后add指令再把这个值加1，结果就保存在EAX寄存器里面。

了解了基于栈的指令集与基于寄存器的指令集的区别后，读者可能会有进一步的疑问，这两套指令集谁更好一些呢？

应该这么说，既然两套指令集会同时并存和发展，那肯定是各有优势的，如果有一套指令集全面优于另外一套的话，就不会存在选择的问题了。

基于栈的指令集主要的优点就是可移植，寄存器由硬件直接提供\[2\]，程序直接依赖这些硬件寄存器则不可避免地要受到硬件的约束。例如，现在32位80x86体系的处理器中提供了8个32位的寄存器，而ARM体系的CPU（在当前的手机、PDA中相当流行的一种处理器）则提供了16个32位的通用寄存器。如果使用栈架构的指令集，用户程序不会直接使用这些寄存器，就可以由虚拟机实现来自行决定把一些访问最频繁的数据（程序计数器、栈顶缓存等）放到寄存器中以获取尽量好的性能，这样实现起来也更加简单一些。栈架构的指令集还有一些其他的优点，如代码相对更加紧凑（字节码中每个字节就对应一条指令，而多地址指令集中还需要存放参数）、编译器实现更加简单（不需要考虑空间分配的问题，所需空间都在栈上操作）等。

栈架构指令集的主要缺点是执行速度相对来说会稍慢一些。所有主流物理机的指令集都是寄存器架构也从侧面印证了这一点。

虽然栈架构指令集的代码非常紧凑，但是完成相同功能所需的指令数量一般会比寄存器架构多，因为出栈、入栈操作本身就产生了相当多的指令数量。更重要的是，栈实现在内存之中，频繁的栈访问也就意味着频繁的内存访问，相对于处理器来说，内存始终是执行速度的瓶颈。尽管虚拟机可以采取栈顶缓存的手段，把最常用的操作映射到寄存器中避免直接内存访问，但这也只能是优化措施而不是解决本质问题的方法。由于指令数量和内存访问的原因，所以导致了栈架构指令集的执行速度会相对较慢。

使用“基本上”，是因为部分字节码指令会带有参数，而纯粹基于栈的指令集架构中应当全部都是零地址指令，也就是都不存在显式的参数。Java这样实现主要是考虑了代码的可校验性。

这里说的是物理机器上的寄存器，也有基于寄存器的虚拟机，如Google Android平台的Dalvik VM。即使是基于寄存器的虚拟机，也希望把虚拟机寄存器尽量映射到物理寄存器上以获取尽可能高的性能。

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

看看在虚拟机中实际是如何执行这个四则运算例子的。

public int calc（）{
        int a=100；
        int b=200；
        int c=300；
        return（a+b）*c；
    }

从Java语言的角度来看，这段代码没有任何解释的必要，可以直接使用javap命令看看它的字节码指令

public int calc（）；
    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
    }

javap提示这段代码需要深度为2的操作数栈和4个Slot的局部变量空间，笔者根据这些信息画了7张图，用它们来描述代码清单8-17执行过程中的代码、操作数栈和局部变量表的变化情况。  
![这里写图片描述][70 1]

![这里写图片描述][70 2]

![这里写图片描述][70 3]

![这里写图片描述][70 4]

上面的执行过程仅仅是一种概念模型，虚拟机最终会对执行过程做一些优化来提高性能，实际的运作过程不一定完全符合概念模型的描述……更准确地说，实际情况会和上面描述的概念模型差距非常大，这种差距产生的原因是虚拟机中解析器和即时编译器都会对输入的字节码进行优化，例如，在HotSpot虚拟机中，有很多“fast\_”开头的非标准字节码指令用于合并、替换输入的字节码以提升解释执行性能，而即时编译器的优化手段更加花样繁多。

不过，我们从这段程序的执行中也可以看出栈结构指令集的一般运行过程，整个运算过程的中间变量都以操作数栈的出栈、入栈为信息交换途径，符合我们在前面分析的特点。

[70]: /images/20220530/58aa63fc130744e2a96ea1dcd85b0c68.png
[70 1]: /images/20220530/b27745d7a6bb4b018b819dcb64646729.png
[70 2]: /images/20220530/29354b76b28e4942bd6b8110211df2f2.png
[70 3]: /images/20220530/f30a98edf46c4383a4310fc56a83f7ab.png
[70 4]: /images/20220530/7cca8362d21a4a68bee2cdf0ef317266.png