写在前面

本文参照《深入理解Java虚拟机》写作而成，算是对自己理解JVM解释执行class文件的一篇总结吧。

整体结构

整体结构

我们知道，Java虚拟机栈是线程私有的，也就是一个线程对应一个栈，那么一个线程当然也可以执行多个方法，每一个方法都对应着一个栈帧。
一个线程的方法调用链可能会很长，很多方法都同时处于执行状态，只有位于栈顶的栈帧才是有效的，称为当前栈帧，与这个栈帧关联的方法称为当前方法。

栈帧(stack frame)

栈帧是用于支持虚拟机进行方法调用和方法执行的数据结构，它是虚拟机运行时数据区的虚拟机栈的栈元素。栈帧中保存了如下几种元素：

1. 局部变量表
   编译时写入Code属性的max_locals数据项中，即局部变量表的最大容量
   局部变量表是一组变量值存储空间，用于存放方法参数和方法内部定义的局部变量。以slot为最小存储单位，每个solt都应该存放一个boolean,byte,char,shot,int,float,reference或returnAddress类型的数据(64位的long和double占两个slot)，其中reference类型表示对一个对象实例的引用，这个引用对虚拟机来说有两个作用：1. 从该引用中直接或者间接的查找对象在Java堆中数据存放的地址索引，2. 通过该引用可以找到该对象的数据类型在方法区所对应的Class对象。
   对于实例方法(非static)，局部变量表的第0位存储的是this对象。
   对于Java中的局部变量，必须先赋值再使用，否则编译将不能通过。

2. 操作数栈
   编译时写入Code属性的max_stacks数据项项中，即栈的最大深度。
   Java编译器输出的指令流是一种基于栈的指令集架构，指令流中的指令大部分都是零地址指令，它们依赖操作数栈进行工作。
   操作数栈中的每一个元素可以是任意的Java类型，32位的栈容量为1，64位栈容量为2。一个方法的执行过程就是一个操作数栈入栈、出栈的过程。
   如整数加法字节码指令iadd会取最接近栈顶的两个int元素，然后将这两个int元素相加之后的结果进行入栈。操作数中的数据类型必须和字节码指令严格匹配。

3. 动态链接
   每个栈帧中都保存着一个执行运行时常量池中该栈帧所属的方法引用，持有这个引用是为了支持Java中动态绑定这个特性。
   我们知道Class文件中包含大量的符号引用，某些符号引用在类加载阶段(具体来说解析阶段)就可以转化为直接引用，这种转化成为静态解析；另一部分将会在每一次运行的时候转化为直接引用，这种转化方式为动态链接。
   关于动态连接，我们通过下文的重载和重写来对动态链接进行具体分析。现在只需要知道动态链接有点像类加载阶段的解析阶段所做的事情(变符号引用为直接引用)，只不过这个过程发生在程序运行的时候。这也是为什么我们称类加载时解析阶段可以运行在初始化阶段之后了。

4. 方法返回地址
   当一个方法开始执行后，只有两种情况可以结束方法的执行。1. JVM执行引擎碰到了任意一个方法返回的字节码指令。2. 在方法的执行过程中碰到了异常。
   方法退出的时候，需要做一些操作，这些操作可能包括：

   1. 恢复上层方法的局部变量表和操作数栈
   2. 把方法返回值压入到调用者的操作数栈中
   3. 执行后一条指令

方法调用

方法调用不等同于方法执行，方法调用阶段唯一的任务就是确定调用方法的版本。
下面是Java中与方法调用有关的指令。

• invokestatic: 调用静态方法
• invokespecial: 调用实例构造器<init>方法，私有方法和父类方法
• invokevirtual: 调用所有的虚方法(包含final定义的方法)
• invokeinterface: 调用接口方法，会在运行时期确定一个实现此接口的对象
• invokedynamic: 在运行时动态解析出符号引用，然后在执行该方法，前面4条指令的分派逻辑是固化在虚拟机内部的，但是这条指令的分派逻辑可以由用户主导。用于开发一些在JVM虚拟机上运行的动态语言(如Groovy)。

从开发者的角度看，Java中除了private,static,final修饰的方法是在类加载的解析阶段可以确定唯一的调用版本，其他的方法都是在运行期间动态的确定调用版本。

从虚拟机的角度看，只要能被invokestatic,invokespecial指令调用的方法，都是能在解析阶段唯一确定调用方法的版本的。这些方法称为非虚方法。相反，其他方法称为虚方法。另外，由于final方法也能唯一确定调用的版本，所以规定final方法也为非虚方法，即使它是被invokevirtual指令调用的。

方法分派

方法分派就是把方法分派给方法的接受者，从另外一个角度来说就是把调用者和方法进行绑定。
方法分派分为 静态分派 和 动态分派，从另外一个角度来说就是静态绑定和动态绑定。

• 什么是静态分派？
  凡是依赖 静态类型 确定方法执行的版本的分派动作都称为静态分派。因为静态类型在编译时期就可确认，所以方法的静态分派发生在编译时期。

• 什么是动态分派？
  这个问题不如转换成为动态分派能够做什么？动态分派能够在运行时确定方法的执行版本。
  动态分派在程序执行时是一个非常频繁的动作，因此在虚拟机的具体实际实现中要基于性能的考虑，最常用的实现手段就是在类的方法区建立一个虚方法表(Virtual Method Table)，当虚拟机遇到invokevirtual指令时，会根据对象的实际类型去查找该类型所对应的虚表，然后确定这个方法的实际入口(完成符号引用变直接引用的操作)。

虚表的结构如下：

虚表.jpg

该表在类加载的连接阶段完成初始化。

静态分派的典型应用就是方法的重载。
动态分派的典型应用就是方法的重写。

方法重载

现有如下代码：

public class StaticDispatch {
    static abstract class Human {
    
    }

    static class Man extends Human {

    }

    static class Woman extends Human {

    }

    public void sayHello(Human human) {
        System.out.println("Hello guy");
    }

    public void sayHello(Man man) {
        System.out.println("Hello man");
    }

    public void sayHello(Woman woman) {
        System.out.println("Hello woman");
    }

    public static void main(String[] args) {
        StaticDispatch o = new StaticDispatch();
        Human man = new Man();
        Human woman = new Woman();
        o.sayHello(man);
        o.sayHello(woman);

    }
}

输出无疑是下列结果：

Hello guy
Hello guy

原因如下：

overload.png

如图，Human类型为静态类型，而Man为变量的实际类型。静态类型在编译时可知，但是实际类型只有在运行阶段才可以确定。编译器重载是通过参数的静态类型确定的。

另外，对于没有显示声明的静态类型，如下

o.sayHello('a');

你可以认为入参类型是如下几种：

1. char
2. int 因为'a'的Unicode数值为十进制的97
3. long 入参自动由整型转换为97L
4. Character 发生了自动装箱，'a'被包装成为它的封装类型java.lang.Character
5. Serializable 因为Character实现了Serializable接口

编译器在编译阶段会按照如下顺序来确定入参的静态类型到底是什么类型
char->int->long->float->double
如果这几种入参都没有对应的重载方法，那么就会对入参进行自动装箱,进行自动装箱之后入参就变成了一个引用类型，按照引用类型的子类从下往上找，越往上的优先级越低，如果出现某个类实现了多个接口，重载方法的入参又恰好是这几个接口类型，那么此时编译器无法确定自动转换为哪种类型，因为他们的优先级是一样的。
我们可以认为Object类型的重载方法的优先级是最低的，因为Object是顶层父类，但是事实上，Java还支持变长的入参类型，声明如下:

@Overload
public void sayHello(char arg...) {
    System.out.println("hello");
}

这种变长类型的入参优先级是最低的，低于Object。
由以上方法的重载的例子可知，确定方法调用的版本需要两个因素决定，一个是调用主体的静态类型，另一个是入参的的静态类型。所以Java中的静态分派是属于多分派类型的。

方法的重写

现有如下代码：

public class OverLoad {
    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

我们使用javap -v OverLoad.class命令查看class文件

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
    stack=2, locals=3, args_size=1
     0: new           #2                  // class OverLoad$Man
     3: dup
     4: invokespecial #3                  // Method OverLoad$Man."<init>":()V
     7: astore_1
     8: new           #4                  // class OverLoad$Woman
    11: dup
    12: invokespecial #5                  // Method OverLoad$Woman."<init>":()V
    15: astore_2
    16: aload_1
    17: invokevirtual #6                  // Method OverLoad$Human.sayHello:()V
    20: aload_2
    21: invokevirtual #6                  // Method OverLoad$Human.sayHello:()V
    24: new           #4                  // class OverLoad$Woman
    27: dup
    28: invokespecial #5                  // Method OverLoad$Woman."<init>":()V
    31: astore_1
    32: aload_1
    33: invokevirtual #6                  // Method OverLoad$Human.sayHello:()V
    36: return

发现执行sayHello()方法的都是通过invokevirtual指令执行常量池中#6，也就是OverLoad$Huamn.sayHello()方法，但是众所周知，这两句指令最终执行的方法是不一样的，原因跟invokevirtual指令有很大关系，invokevirtual指令在运行时的解析过程如下：

1. 找到操作数栈栈顶元素所指对象的实际类型，记做C
2. 如果在类型C中找到和常量池中的描述符相同的方法，则进行访问权限的校验，如果校验通过返回这个方法的直接引用，查找过程结束；如果不通过，返回java.lang.IllegalAccessError异常
3. 否则，按照继承关系从下往上依次对C的各个父类执行搜索和验证过程
4. 如果没有找到合适的方法，抛java.lang.AbstractMethodError异常

由于invokevirtual指令执行的第一步就是在运行期确定方法调用者的实际类型，所以两次调用中的invokeVirtual指令把常量池中的符号引用解析到了不同的直接引用上，这个过程就是Java语言重写的本质。
可以看出，动态分派只关心运行时对象的时机类型，所以动态分派属于单分派类型。