6.虚拟机字节码执行引擎

执行引擎在执行JAVA代码的时候可以选择解释执行（通过解释器执行）和编译执行（通过即使编译器产生本地代码执行）两种选择。

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

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

局部变量表

用于存放方法参数和方法内部定义的局部变量，在编译成CLASS文件时，就在方法的CODE属性的max_locals数据项中确定了该方法所需要分配的最大局部变量表的容量。

局部变量表的容量以变量槽(Variable Slot)为最小单位，虚拟机规范中并没有明确指出一个slot应占用的内存空间大小。

一个Slot可以存放一个32位以内的数据类型，这些类型有：boolean,byte,char,short,int,float,reference和returnAddress。returnAddress是为字节码指令jsr,jsr_w和ret服务的，指向下一条字节码的地址。

对于64位数据，JVM会以高位在前的方式分配两个连续的Slot空间。

JAVA明确规定的64位数据只有long和double两种。reference可能是32也可能是64位

JVM通过索引定位的方式使用局部变量表，索引值的范围从0开始到局部变量表最大的SLOT数量。

在方法执行时，JVM使用局部变量表完成参数值到参数变量列表的传递过程。如果是实例方法，那么局部变量表的第0位索引的SLOT默认是用于传递方法所属对象实例的引用，在方法中可以通过“this"访问到这个隐含的参数。其余参数则按照参数表的顺序排列，参数表分配完毕后，再根据方法体内部定义的变量顺序和作用于分配其余SLOT。

局部变量表中的SLOT是可以重用的，如果当前字节码PC计数器的值已经超出了某个变量的作用域，那么这个变量对应的SLOT就可以交给其他变量使用。

Java代码

1. public static void main(String[] args)(){   
2.         {   
3.                 byte[] placeholder = new byte[64* 1024 * 1024];   
4.         }   
5.         System.gc();   
6. }  

public static void main(String[] args)(){
        {
                byte[] placeholder = new byte[64* 1024 * 1024];
        }
        System.gc();
}

 一般认为，在大括号结束后，placeholder已经处于可以回收的状态，因为变量作用域已经超过，此时调用System.gc()理应能回收之前分配的内存，但是实际上这块内存没有被回收，这是因为局部变量表中SLOT还存在有关于placeholder数组对象的引用，如果在大括号中加入int a=0;语句，虽然看似无关，但该语句重写了局部变量表，使变量表中作为GC Roots的部分被覆盖，后面的回收操作就可以进行了。

根据上面的例子，如果在某个方法中，方法前面分配了大量的内存给后面又用不到的变量，而后面的代码又有一些耗时很长的操作，应该把前面的变量置为null,，可以将变量对应的局部变量表清空。但是，赋为NULL的操作在经过JIT编译后，会被忽略掉，因此在这种情况下，是没有意义的。

操作数栈

LIFO。操作数栈的最大深度在编译时写入到Code属性的max_stacks数据项中。

操作数栈的每一个元素可以是任意JAVA数据类型，32位数据占栈容量为1，64位占栈容量为2.

当一个方法开始执行时，这个方法的操作数栈是空的，在方法执行过程中，会有各种字节码指令向操作数栈中写入和提取内容。比如，加法的字节码指令iadd在运行时会将栈顶两个元素相加并出战，再将结果入栈。

在编译器和校验阶段的保证下，操作数栈中元素的数据类型必须与字节码指令的序列严格匹配。

动态连接

每个栈帧都包含一个指向运行时常量池中该栈帧所属方法的引用，持有这个引用是为了支持方法调用过程中的动态连接。

字节码中的方法调用指令就以常量池中指向方法的符号引用为参数。这些符号引用一部分会在类加载阶段或第一次使用的时候转换为直接引用，成为静态解析，另一部分会在每一次运行时转换为直接引用，成为动态连接

方法返回地址

有两种方式退出当前执行的方法，一是执行引擎遇到任意一个方法返回的字节码指令，这种方法称为正常完成出口。

二是在方法执行过程中遇到无法处理的异常，这种方法称为异常完成出口。

无论哪种方法，方法退出后，都需要返回到调用者的位置，正常退出时，调用者的PC计数器值可以作为返回地址，栈帧中很可能会保存这个计数器值，而异常退出时，返回地址要通过异常处理器表来确定。

方法退出的过程实际上是将当前栈帧出战，并恢复上层方法的局部变量表和操作数栈，把返回值压入调用者的操作数栈中。

方法调用

方法调用不等于方法执行，其唯一的任务就是确定调用哪一个具体方法。

解析

所有方法调用中的目标方法在Class文件里面都是一个常量池中的符号引用。

在类加载的解析阶段，一部分符号引用会被转化为直接引用，这种解析成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，且这个方法的调用版本在运行时是不可改变的。符合这个条件的有静态方法和私有方法两大类。

JVM提供了4条方法调用的字节码指令：

1. invokestatic:调用静态方法
2. invokespecial:调用实例构造器<init>方法，私有方法和父类方法
3. invokevirtual:调用所有的虚方法
4. invokeinterface:调用接口方法，会在运行时再确定一个实现此接口的对象。

只要能被 invokestatic和 invokespecial调用的方法，都可以 在解析阶段进行转化。

除此以外（除 静态方法，实例构造器，私有方法，父类方法以外）其他方法称为虚方法。

JAVA非虚方法除了invokestatic和invokespecial以外，还有一种就是final修饰的方法，因为该方法无法被覆盖，这种被final修饰的方法是用 invokevirtual指令调用的。

分派

静态分派

Parent father = new Son();

这句中，Parent被称为静态类型，Son称为实际类型。

虚拟机（编译器）重载时通过参数的静态类型作为判断依据。 所有依赖静态类型来定位方法执行版本的分派动作，都称为静态分派。静态分派的最典型应用就是方法重载。

在重载的情况下，很多时候重载版本并不是唯一的，而是寻找一个最合适的版本。比如存在多个重载方法的情况中，调用的目标顺序是一定的。

动态分派

它与重写（override）有着密切的关系。

相对于前面的重载中， 引用类型对于具体调用哪个方法起决定性作用，在重写中， 引用指向的对象的具体类型决定了调用的具体目标方法。

Java代码

1. Human man = new Man();   
2. Human woman = new Woman();   
3. man.sayHello();   
4. woman.sayHello();   
5. man = new Woman();   
6. man.sayHello();  

Human man = new Man();
Human woman = new Woman();
man.sayHello();
woman.sayHello();
man = new Woman();
man.sayHello();

 

这样一段代码生成的字节码为：

Java代码

1. 0: new #16;   
2. 3; dup   
3. 4: invokespecial #18;   
4. 7; astore_1   
5. 8: new #19;   
6. 11:dup   
7. 12:invokespecial #21;   
8. 15:astore_2   
9. 16:aload_1   
10. 17:invokevirtual #22;   
11. 20:aload_2   
12. 21:invokevirtual #22;   
13. 24:new #19;   
14. 27:dup   
15. 28:invokespecial #21;   
16. 31:astore_1   
17. 32:aload_1   
18. 33:invokevirtual #22  
19. 36:return  

0: new #16;
3; dup
4: invokespecial #18;
7; astore_1
8: new #19;
11:dup
12:invokespecial #21;
15:astore_2
16:aload_1
17:invokevirtual #22;
20:aload_2
21:invokevirtual #22;
24:new #19;
27:dup
28:invokespecial #21;
31:astore_1
32:aload_1
33:invokevirtual #22
36:return

 0-15行是准备工作，用于生成对象，初始化对象，并将两个实例存放在第一和第二个局部变量表slot中。

16和20行分别将刚创建的两个对象引用压到栈顶，这两个对象是将要执行的sayHello()方法的所有者，成为接收者。

17和21行是方法调用指令，可见指令和参数都是一样的，都是invokevirtual常量池中第22项的常量---Human.sayHello()的符号引用，而结果是这两次调用的结果不同，原因是 invokevirtual指令的运行时解析过程：

1. 找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C
2. 如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，通过则返回该方法直接引用，不通过抛出java.lang.IllegalAccessError
3. 否则，按照继承关系从下往上一次对C的各个父类进行第二步的搜索和验证
4. 没找到合适方法，抛出java.lang.AbstractMethodError异常

由于第一步是解析成对象的实际类型，因此两次调用的结果不一样。

这个顺序实际是：

找到实际类型---在该类型中搜索--在该类型的继承结构中自下而上搜索---抛出异常

在运行期根据实际类型确定方法执行版本的分派过程称为动态分派。

单分派和多分派

方法的接收者与方法的参数统称为方法的宗量。

根据分派基于多少种宗量，可以将分派划分为单分派和多分派两种

单分派是根据一个宗量对目标方法进行选择，

多分派是根据多于一个宗量对目标方法进行选择。

（同时有重载和重写发生的情况）

根据之前方法调用可能生成的4种字节码，找到对应方法可能生成的字节码，再根据字节码解析过程进行判断。

首先进行静态分派，生成相应的字节码，在常量池中生成对应的方法符号引用，这个过程根据了两个宗量进行选择（接收者和参数），因此静态分派是多分派类型。

再进行动态分派，将符号引用变成直接引用时，只对方法的接收者进行选择，因此只有一个宗量，动态分派是单分派。

虚拟机动态分派的实现

由于动态分派是非常频繁的操作，因此在JVM具体实现中基于性能考虑，常常 做一些优化，最初那个用的“稳定优化”手段就是为类在方法去中建立一个虚方发表（vtable），于此对应，invokeinterface执行时也会用到接口方发表，itable。

虚方法表中存放着各个方法的实际入口地址，如果某个方法在子类中没有被重写，那么子类的虚方法表里的地址入口和父类相同方法的地址入口是一致的。如果子类重写了这个方法，子类方法表中的地址就会被替换为指向子类实现版本的入口地址。为了程序实现上的方百年，具有相同签名的方法，在父类、子类的虚方发表中都应当具有一样的索引序号，这样当类型变换时，仅需要变更要查找的方法表即可。方法表一般在类加载的连接阶段进行初始化，准备了类的变量初始值后，虚拟机会把该类的方法表也初始化完毕。

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

Java编译器输出的指令流，基本上是一种基于栈的指令集架构，与之对应的是寄存器指令集架构。

比较起来，基于栈的指令集主要的优点是可移植性。而寄存器架构有更好的性能。