虚拟机字节码执行引擎

我们的JVM执行引擎属于JVM的下层，里面包括了解释器，及时编译器，垃圾回收器

• 我们的执行引擎是Java虚拟机的核心组成部分之一，虚拟机相对于物理机的概念，这两种机器都有代码执行的能力，其区别是物理机的执行引擎是直接建立在处理器，缓存，指令集和操作系统层面上，而虚拟机的执行引擎是由软件自行实现,因此可以不受物理条件制约地制定指令集与执行引擎的结构体系，能够执行哪些不被硬件直接支持的指令集格式——代码编译的结果从本地机器码转变为字节码
• JVM的主要任务是负责装载字节码到其内部，但字节码并不能够直接运行在操作系统之上，因为字节码指令并非等价于本地机器指令，它内部包含的仅仅只是一些能够被JVM所识别的字节码指令、符号表，以及其他辅助信息。
• 那么，如果想要让一个Java程序运行起来，执行引擎（Execution Engine）的任务就是将字节码指令解释/编译为对应平台上的本地机器指令.才可以。简单来说，JVM中的执行引擎充当了将高级语言翻译为机器语言的译者。
• 在我们的不同的虚拟机实现中，通常有解释执行（解释器）和编译执行（通过编译器产生本地代码执行）两种选择，也可以两者兼备，我们HotSpot就是两者兼备

这些具体的我们在后面的前端编译器和后端编译再详细介绍，我们在这里讲述虚拟机方法的调用和字节码执行——因为我们运行的基本单位就是方法，我们的运行的代码都是在方法中

运行时栈帧结构

每个栈帧存储着：

• 局部变量表（Local Variables）
• 操作数栈（Operand Stack）或叫表达式栈
• 动态链接 或叫指向运行时常量池的方法引用
• 方法返回地址 或者叫方法正常退出或者异常退出的定义
• 一些附加信息

在编译Java程序源码的时候，栈帧中需要多大的局部变量表，需要多深的操作数栈就已经被分析计算出来了，并且写入到方法表的Code属性之中

并行下每个线程下的栈都是私有的，因此每个线程都有自己各自的栈，每个栈中有多个栈帧，栈帧的大小主要由我们局部变量表和操作数栈决定的

对于执行引擎来说，在活动线程中，只有位于栈顶的方法才是运行的，只有位于栈顶的栈帧才是生效的，与这个栈帧所关联的方法被称为“当前方法”

局部变量表（Local Variables）

局部变量表也被称为局部变量数组或者本地变量表

• 定义成一个数字数组，主要存储方法参数和定义在方法体内的局部变量，这些数据类型包含各类基本数据类型，对象引用，以及returnAddress类型
• 局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。
• 局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束后，随着方法栈帧的销毁，局部变量表也会随之销毁。
• 由于局部变量表是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
  • 理论上是这样的，如果对象是在内部产生，在内部销毁，没有返回到外部，那么就是线程安全的，反之就不是线程安全的
  • 像基本类型的局部变量就不会有安全问题，因为Java是传值操作，但是引用类型就不一样了，就有可能出方法的范围

例子

Slot的概念

• 局部变量表，最基本的存储单元是Slot（变量槽）

  • Java虚拟机规范中并没有明确指出一个变量槽应占用的内存空间，只是很有导向性的说每个变量槽都应该能存放一个boolean,byte,char,short,int,int,float,reference或者returnAddress这8个数据类型

• 在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位的类型（long和double）占用两个slot。

• byte、short、char 在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true。

• 参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束。

• JVM会为局部变量表中的每一个Slot都分配一个访问索引，通过这个索引即可成功访问到局部变量表中指定的局部变量值

  • 如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可。（比如：访问long或doub1e类型变量）

• 当一个实例方法被调用的时候，它的方法参数和方法体内部定义的局部变量将会按照顺序被复制到局部变量表中的每一个slot上

• 如果当前帧是由构造方法或者实例方法创建的，那么该对象引用this将会存放在index为0的slot处,表示当前对象的引用，其余的参数按照参数表顺序继续排列。

  • 这也是为什么我们在静态方法中不能使用this,也不能直接调用成员属性（可以通过对象调用），因为直接调用在编译之后，还是通过this来调用

例子

Slot的重复利用

为了尽可能节省栈帧所耗用的内存空间，所以局部变量的变量槽是可以复用的，因为我们方法体中定义的变量，其作用率并不一定会覆盖整个方法体

• 我们的变量C就是占用我们的b所占用的slot位置

静态变量与局部变量的对比

变量按照数据类型分

• 基本数据类型
• 引用数据类型

变量按照位置分

• 成员变量 在使用前都会进行默认初始化
  • 类变量(不包括类常量 static final) 在链接的准备阶段给类变量默认赋初值，在初始化的时候进行显示初始化（静态代码块或者是类变量赋值）
  • 实例变量 随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值
• 局部变量 在使用前，必须要进行显示赋值，否则，编译不通过

补充

在栈帧中，与性能调优关系最为密切的部分就是前面提到的局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。

局部变量表中的变量也是重要的垃圾回收根节点，只要被局部变量表中直接或间接引用的对象都不会被回收。

操作数栈

每一个独立的栈帧除了包含局部变量表以外，还包含一个后进先出（Last-In-First-Out）的 操作数栈，也可以称之为表达式栈（Expression Stack）

操作数栈，在方法执行过程中，根据字节码指令，往栈中写入数据或提取数据，即入栈（push）和 出栈（pop）

• 某些字节码指令将值压入操作数栈，其余的字节码指令将操作数取出栈。使用它们后再把结果压入栈

• 比如：执行复制、交换、求和等操作

public void testAddOperation() {
        //byte、short、char、boolean：都以int型来保存
        byte i = 15;
        int j = 8;
        int k = i + j;
       // int m = 800;
}

 //编译后的字节码
 0 bipush 15      将15压入操作数栈
 2 istore_1       将15存储到局部变量表 i表示的int
 3 bipush 8       将8压入操作数栈
 5 istore_2       将8存储到局部变量表 i表示的int
 6 iload_1        将栈顶元素取出
 7 iload_2        将栈顶元素取出
 8 iadd           做加法操作 并入栈
 9 istore_3       存储到局部变量表
10 return

• 操作数栈，主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。
• 操作数栈就是JVM执行引擎的一个工作区，当一个方法刚开始执行的时候，一个新的栈帧也会随之被创建出来，这个方法的操作数栈是空的。
• 每一个操作数栈都会拥有一个明确的栈深度用于存储数值，其所需的最大深度在编译期就定义好了，保存在方法的Code属性中，为max_stack的值。
• 栈中的任何一个元素都是可以任意的Java数据类型
  • 32bit的类型占用一个栈单位深度
  • 64bit的类型占用两个栈单位深度
• 操作数栈并非采用访问索引的方式来进行数据访问的（因为栈的结构决定），而是只能通过标准的入栈和出栈操作来完成一次数据访问
• 如果被调用的方法带有返回值的话，其返回值将会被压入当前栈帧的操作数栈中，并更新PC寄存器中下一条需要执行的字节码指令。
• 操作数栈中元素的数据类型必须与字节码指令的序列严格匹配，这由编译器在编译器期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段要再次验证。
• 另外，我们说Java虚拟机的解释引擎是基于栈的执行引擎，其中的栈指的就是操作数栈。

动态链接（Dynamic Linking）

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

在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池里。比如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是为了将这些符号引用转换为调用方法的直接引用。

为什么需要运行时常量池呢？

常量池的作用：就是为了提供一些符号和常量，便于指令的识别

方法返回地址

当一个方法开始执行，只有两种方式退出这个方法

1. 执行引擎遇到任意一个方法返回的字节码指令，这种可能会有返回值返回给上一层的调用者
2. 另一种退出方式就是在方法执行过程中遇到了异常，并且这个异常在方法执行过程中没有得到妥善的处理

无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置。方法正常退出时，调用者的pc计数器的值作为返回地址，即调用该方法的指令的下一条指令的地址。而通过异常退出的，返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息。

1. 执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者，简称正常完成出口；

• • 一个方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定。
• • 在字节码指令中，返回指令包含ireturn（当返回值是boolean，byte，char，short和int类型时使用），lreturn（Long类型），freturn（Float类型），dreturn（Double类型），areturn。另外还有一个return指令声明为void的方法，实例初始化方法，类和接口的初始化方法使用。

1. 在方法执行过程中遇到异常（Exception），并且这个异常没有在方法内进行处理，也就是只要在本方法的异常表中没有搜索到匹配的异常处理器，就会导致方法退出，简称异常完成出口。
   • 方法执行过程中，抛出异常时的异常处理，存储在一个异常处理表，方便在发生异常的时候找到处理异常的代码

正常完成出口和异常完成出口的区别在于：通过异常完成出口退出的不会给他的上层调用者产生任何的返回值。

异常表演示

---

附加信息

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

一般把附件信息，动态链接，方法返回地址信息统称为一类，称为栈帧信息

方法调用

方法调用并不等同于方法中的代码被执行，方法调用阶段的唯一任务就是确定被调用方法的版本（即调用哪一个方法），我们知道在Java中一切方法调用在Class文件中存储的都是符号引用，而不是方法在实际运行时内存布局中的入口地址，所以调用方法可能在类加载期间，或者是在运行期间才能确定目标方法的直接引用,所以根据不同时期被确定成直接引用分为解析和分派

解析

解析就是在类加载的解析阶段，会将其中的一部分符号引用转换为直接引用

• 前提条件就是方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期间是不可改变的

分派

静态分配——对应重载

分派这个词本身是具有动态性，一般不应用在静态语境之中，本应该是在解析中讲解，但是很多资料将其称为静态分派

Human man=new Man();

将上面代码中的Human，称为变量的静态类型，而后面的Man被称为运行时类型，静态类型和运行时类型可能都会发生变换，但是存在不同

• 静态类型的变化仅仅在使用时发生，并且在最终的静态类型是在编译期间可知
  • 虽然会有变化，但是对于编译器都是可知的
• 而运行是类型的变化的结果是在运行期间才能确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么

/**
 * @description: 静态分派调用示例
 * @author: xz
 */
public class Test3 {
    static  class Parent{

    }

    static class Child1 extends Parent{

    }

    static class Child2 extends Parent{

    }

    public void hello(Parent parent){
        System.out.println("hello parent");
    }

    public void hello(Child1 child1){
        System.out.println("hello child1");
    }

    public void hello(Child2 child2){
        System.out.println("hello child2");
    }

    public static void main(String[] args) {
        Parent p1 = new Child1();
        Parent p2 = new Child2();

        Test3 test3 = new Test3();
        test3.hello(p1);
        test3.hello(p2);
    }
}
//输出结果
hello parent
hello parent

• 对于使用哪个重载版本，完全取决于我们的传入的参数的数量和数据类型，但是虚拟机（准确说是编译器）在通过变量的静态类型来作为判断，而不是我们的运行时类型
• 所有依赖静态类型来决定方法执行版本的分派动作称为静态分派，最经典的运用就是方法重载

动态分派——方法重写

public class DynamicDispatch {
	static abstract class Human{
		protected abstract void sayHello();
	}
	static class Man extends Human{ 
		@Override
		protected void sayHello() { 
			System.out.println("man say hello!");
		}
	}
	static class Woman extends Human{ 
		@Override
		protected void sayHello() { 
			System.out.println("woman say hello!");
		}
	} 
	public static void main(String[] args) {
		
		Human man=new Man();
		Human woman=new Woman();
		man.sayHello();
		woman.sayHello();
		man=new Woman();
		man.sayHello(); 
	}
}
//输出结果
man say hello!
woman say hello!
woman say hello!

显然，这里不可能再根据静态类型来决定，因为静态类型同样是Human的两个变量man和woman在调用sayHello()方法时执行了不同的行为，并且变量man在两次调用中执行了不同的方法。导致这个现象的原因很明显，是这两个变量的实际类型不同，Java虚拟机是如何根据实际类型来分派方法执行版本的呢？

 0 new #2 //<com/atguigu/java/DynamicDispatch$Man>
 3 dup
 4 invokespecial #3  //<com/atguigu/java/DynamicDispatch$Man.<init> : ()V>
 7 astore_1
 8 new #4 //<com/atguigu/java/DynamicDispatch$Woman>
11 dup
12 invokespecial #5 //<com/atguigu/java/DynamicDispatch$Woman.<init> : ()V>
15 astore_2
16 aload_1
17 invokevirtual #6 //<com/atguigu/java/DynamicDispatch$Human.sayHello : ()V>
20 aload_2
21 invokevirtual #6 //<com/atguigu/java/DynamicDispatch$Human.sayHello : ()V>
24 new #4 //<com/atguigu/java/DynamicDispatch$Woman>
27 dup
28 invokespecial #5 //<com/atguigu/java/DynamicDispatch$Woman.<init> : ()V>
31 astore_1
32 aload_1
33 invokevirtual #6 //<com/atguigu/java/DynamicDispatch$Human.sayHello : ()V>
36 return
//17和21的invokevirtual 导致的

我们从invokevirtual指令的多态查找过程开始说起，invokevirtual指令的运行时解析过程大致分为以下几个步骤：

1、找到操作数栈顶的第一个元素所指向的对象的运行时类型，记作C。
2、如果在类型C中找到与常量中的描述符和简单名称相符合的方法，然后进行访问权限验证，如果验证通过则返回这个方法的直接引用，查找过程结束；如果验证不通过，则抛出java.lang.IllegalAccessError异常。
3、否则未找到，就按照继承关系从下往上依次对类型C的各个父类进行第2步的搜索和验证过程。
4、如果始终没有找到合适的方法，则跑出java.lang.AbstractMethodError异常。

由于invokevirtual指令执行的第一步就是在运行期确定接收者的实际类型，所以两次调用中的invokevirtual指令把常量池中的类方法符号引用解析到了不同的直接引用上，这个过程就是Java语言方法重写的本质。我们把这种在运行期根据实际类型确定方法执行版本的分派过程称为动态分派。

IllegalAccessError介绍

程序试图访问或修改一个属性或调用一个方法，这个属性或方法，你没有权限访问。一般的，这个会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变。

注意

• 这种多态性的根源是虚方法调用指令invokevirtual，所以我们的属性是不具有多态性的

public class FiledHasNoPolymorphic {
    static class Father{
        public int money=1;
        public Father(){
            money=2;
            show();
        }

        public void show() {
            System.out.println("I am Father,i have $"+money);
        }
    }
    static class Son extends Father{
        public int money=3;
        public Son(){
            money=4;
            show();
        }

        public void show(){
            System.out.println("I am Son,i have $"+money);
        }
    }

    public static void main(String[] args) {
        Father guy=new Son();
        System.out.println("This guy has $"+guy.money);
    }
}
//输出结果
I am Son,i have $0 //因为调用了Son的init方法，首先要调用父类的init方法（会有隐式一个super()），但是因为方法的多态性，所以父类的中的show方法调用的是Son的，因为new的对象是Son的
I am Son,i have $4
This guy has $2 //因为我们属性不具有多态性，所以由我们的静态类型确定

虚方法和非虚方法

我们知道解析的条件就是编译器期间可知，运行期间不可变，而我们把这种方法称作非虚方法

非虚方法

• 静态方法 （属于类，不属于方法）
• 私有方法 （不能在子类重写）
• final方法 （不可重写）
• 实例构造器 （在新建对象的时候，参数必须确定）
• 调用父类方法

虚拟机中提供调用指令

普通调用指令：

• invokestatic：调用静态方法，解析阶段确定唯一方法版本

• invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本

• invokevirtual：调用所有虚方法

• invokeinterface：调用接口方法

动态调用指令：

• invokedynamic：动态解析出需要调用的方法，然后执行

前四条指令固化在虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本。其中invokestatic指令和invokespecial指令调用的方法称为非虚方法，其余的（final修饰的除外,final修饰的方法也是财团invokevirtual）称为虚方法。

class Father {
    public static void print(String str) {
        System.out.println("father " + str);
    }
    private void show(String str) {
        System.out.println("father " + str);
    }
}
class Son extends Father {
}
public class VirtualMethodTest {
    public static void main(String[] args) {
        Son.print("coder");
//        Father fa = new Father();
//        fa.show("cooooder");
    }
}

• 我们发现Son.print(“coder”),是通过invokestatic命令来调用print方法，其调用的方法版本已经在编译期间就是明确（以常量池项的形式固化在字节码指令的参数之中）常量池的#3

关于invokednamic指令

• JVM字节码指令集一直比较稳定，一直到Java7中才增加了一个invokedynamic指令，这是Java为了实现「动态类型语言」支持而做的一种改进。

• 但是在Java7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM这种底层字节码工具来产生invokedynamic指令。直到Java8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式。

• Java7中增加的动态语言类型支持的本质是对Java虚拟机规范的修改，而不是对Java语言规则的修改，这一块相对来讲比较复杂，增加了虚拟机中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器。

动态类型语言和静态类型语言

动态类型语言和静态类型语言两者的区别就在于对类型的检查是在编译期还是在运行期，满足前者就是静态类型语言，反之是动态类型语言。

说的再直白一点就是，静态类型语言是判断变量自身的类型信息；动态类型语言是判断变量值的类型信息，变量没有类型信息，变量值才有类型信息，这是动态语言的一个重要特征。

虚拟机动态分派的实现

在面向对象的编程中，会很频繁的使用到动态分派，如果在每次动态分派的过程中都要重新在类的方法元数据中搜索合适的目标的话就可能影响到执行效率。因此，为了提高性能，JVM采用在类的方法区建立一个虚方法表 （virtual method table）（非虚方法不会出现在表中）来实现。使用索引表来代替查找。

每个类中都有一个虚方法表，表中存放着各个方法的实际入口。

虚方法表是什么时候被创建的呢？

虚方法表会在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

interface Friendly{
    void sayHello();
    void sayGoodbye(); 
}
class Dog{
    public void sayHello(){
    }
    public String tostring(){
        return "Dog";
    }
}
class Cat implements Friendly {
    public void eat() {
    }
    public void sayHello() { 
    } 
    public void sayGoodbye() {
    }
    protected void finalize() {
    }
}
class CockerSpaniel extends Dog implements Friendly{
    public void sayHello() { 
        super.sayHello();
    }
    public void sayGoodbye() {
    }
}

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

我们这里的分析都是基于概念模型下的Java虚拟机解释器执行字节码时，其执行引擎怎么工作的，因为真正的实现会有不同，比如HotSpot的模板解释器会动态的产生每条字节码对应的汇编代码来运行，但是我们基于概念模型下的执行结果是一样的

• Java语言经常被人们定位为解释执行的语言，在Java初生的JDK1.0时代，这种定义还是比较准确的，但当主流的虚拟机都包含了即时编译器之后，class文件中的代码到底会被解释执行还是编译执行，就成了只有虚拟机自己才能准确判断的事
• 无论物理虚拟机还是物理机，无论是解释还是编译，无论是将代码转换成物理机的目标代码还是虚拟机的指令集，都需要经过上面橙色的步骤，对于蓝色的步骤是我们传统编译原理中程序代码到目标机器代码的生成过程，而中间绿色的步骤就是我们的解释执行

例子

栈顶缓存技术（Top Of Stack Cashing）技术

前面提过，基于栈式架构的虚拟机所使用的零地址指令更加紧凑，但完成一项操作的时候必然需要使用更多的入栈和出栈指令，这同时也就意味着将需要更多的指令分派（instruction dispatch）次数和内存读/写次数。

由于操作数是存储在内存中的，因此频繁地执行内存读/写操作必然会影响执行速度。为了解决这个问题，HotSpot JVM的设计者们提出了栈顶缓存（Tos，Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率。