JVM：方法调用之分派。

淩亂°似流年 2022-01-26 14:29 212阅读 0赞

众所周知，Java是一门面向对象的程序语言，因为Java具备面向对象的3个基本特征：继承、封装和多态。本文讲解的分派调用过程将会揭示多态性特征的一些最基本的体现，***如“重载”和“重写”在Java虚拟机之中是如何实现的***，这里的实现当然不是语法上该如何写，我们关心的依然是虚拟机如何确定的目标方法。

# 静态分派（重载） #

在开始讲解静态分派前，这里准备了一段经常出现在面试题中的程序代码，后面我们的话题将围绕这个类的方法来重载（Overlaod）代码，以分析虚拟机和编译器确定方法版本的过程。方法静态分派如下面代码所示。

/**
     *	方法静态分派演示 
     */
    public class StaticDispatch {
    	static abstract class Human {
    	}
    	static class Man extends Human {
    	}
    	static class Woman extends Human {
    	}
    	public void sayHello(Human guy) {
    		System.out.println("hello, guy!");
    	}
    	public void sayHello(Man guy) {
    		System.out.println("hello,gentleman!");
    	}
    	public void sayHello(Woman guy) {
    		System.out.println("hello,lady!");
    	}
    	public static void main(String[] args) {
    		Human man = new Man();
    		Human woman = new Woman();
    		StaticDispatch sr = new StaticDispatch();
    		sr.sayHello(man);
    		sr.sayHello(woman);
    	}
    }

运行结果：

> hello, guy!  
> hello, guy!

上面代码实际上是在考验阅读者对重载的理解程度，相信对Java编程稍有经验的程序员看完程序后都能得出正确的运行结果，但为什么会选择执行参数类型为Human的重载呢？在解决这个问题之前，我们先按如下代码定义两个重要的概念。

Human man = new Man();

我们把上面代码中的“Human”称为变量的静态类型（Static Type），或者叫做外观类型（Apparent Type），后面的“Man”则称为变量的实际类型（Actual Type），静态类型和实际类型在程序中都可以发生一些变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态类型是在编译期可知的；而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么。例如下面的代码：

Human man = new Man();
    		Human woman = new Woman();
    		StaticDispatch sr = new StaticDispatch();
    		// 静态类型变化
    		sr.sayHello((Man)man);
    		sr.sayHello((Woman)woman);

解释了这两个概念，再回到第一个样例代码。main()里面的两次sayHello()方法调用，在方法接收者已经确定是对象“sr”的前提下，使用哪个重载版本，就完全取决于传入参数的数量和数据类型。代码中刻意的定义了两个静态类型相同但实际类型不同的变量，但虚拟机（准确的说是编译器）在重载时是通过参数的静态类型而不是实际类型作为判定依据的。并且静态类型是编译器可知的，因此，在编译阶段，Javac编译器会根据参数的亭台类型决定使用哪个重载版本，所以选择了sayHello(Human)作为调用目标，并把这个方法的符号引用写到main()方法里的两条invokevirtual指令的参数中。  
所有依赖静态类型来定位方法执行版本的分派动作称为静态分派。静态分派的典型应用是方法重载。静态分派发生在编译阶段，因此确定静态分派的动作实际上不是由虚拟机来执行的。另外编译器虽然能确定出方法的重载版本，但在很多情况下这个重载版本并不是“唯一的”，往往只能确定一个“更加合适的”版本。这种模糊的结论在由0和1够成的计算机世界中算是比较“稀罕”的事情，产生这种模糊结论的主要原因是字面量不需要定义，所以字面量没有显式的静态类型，他的静态类型只能通过语言上的规则去理解和推断。下面代码演示了何为“更加合适的”版本。

public class Overload {
    	public static void sayHello(Object arg) {
    		System.out.println("hello Object");
    	}
    	public static void sayHello(int arg) {
    		System.out.println("hello int");
    	}
    	public static void sayHello(long arg) {
    		System.out.println("hello long");
    	}
    	public static void sayHello(Character arg) {
    		System.out.println("hello Character");
    	}
    	public static void sayHello(char arg) {
    		System.out.println("hello char");
    	}
    	public static void sayHello(char... arg) {
    		System.out.println("hello char...");
    	}
    	public static void sayHello(Serializable arg) {
    		System.out.println("hello Serializable");
    	}
    	public static void main(String[] args) {
    		sayHello('a');
    	}
    }

上面代码运行后会输出：

> hello char

这很好理解，'a'是一个char类型的数据，自然会寻找参数类型为char的重载方法，如果注释掉sayHello(char arg)方法，那输出会变为：

> hello int

这时发生了一次自动类型转换，'a'除了可以代表一个字符串，还可以代表数字97（字符'a'的Unicode数值为十进制数字97），因此参数类型为int的重载也是合适的。我们继续注释掉sayHello(int arg)方法，那输出会变为：

> hello long

这时发生了两次自动类型转换，'a'转型为整数97之后，进一步转型为长整数97L，匹配了参数类型为long的重载。在代码中没有写其他的类型如float、double等的重载，不过实际上自动转型还能继续发生多次，按照char→int→long→float→double的顺序转型进行匹配。但不会匹配到byte和short类型的重载，因为char到byte或short的转型是不安全的。我们继续注释掉sayHello(long arg)方法，那输出会变为：

> hello Character

这时发生了一次自动装箱，'a'被包装为他的封装类型java.lang.Character，所以匹配到了参数类型为Character的重载，继续注释掉sayHello(Character arg)方法，那输出会变为：

> hello Serializable

这个输出可能会让人感觉摸不着头脑，一个字符或数字与序列化有什么关系？出现hello Serializable，是因为java.lang.Serializable是java.lang.Character类实现的一个接口，当自动装箱之后发现还是找不到装箱类，但是找到了装箱类实现了的接口类型，所以紧接着又发生一次自动转型。char可以转型成int，但是Character是绝对不会转型为Integer的，他只能安全的转型为他实现的接口或父类。Character还实现了另外一个接口java.lang.Comparable<Character>，如果同时出现两个参数分别为Serializable和Comparable<Character>的重载方法，那他们在此时的优先级是一样的。编译器无法确定要自动转型为哪种类型，会提示类型模糊，拒绝编译。程序必须在调用时显式的指定字面量的静态类型，如：sayHello((Comparable<Character>)'a')，才能编译通过。下面继续注释掉sayHello(Serializable arg)方法，输出会变为：

> hello Object

这时是char装箱后转型为父类了，如果有多个父类，那将在继承关系中从下往上开始搜索，越接近上层的优先级越低。即使方法调用传入的参数值为null值，这个规则仍然适用。我们把sayHello(Object arg)也注释掉，输出将会变为：

> hello char...

7个重载方法已经被注释的只剩下一个了，可见变长参数的重载优先级是最低的，这时候字符'a'被当作了一个数组元素。这里使用的是char类型的变长参数，读者在验证时还可以选择int类型、Character类型、Object类型等的变长参数重载来把上面的过程重新演示一遍。但要注意的是，有一些在单个参数中能成立的自动转型，如char转型为int，在变长参数中是不成立的。  
上面代码演示了编译期间选择静态分派目标的过程，这个过程也是Java语言实现方法重载的本质。演示所有的这段程序属于很极端的例子，除了用作面试题为难求职者以外，在实际工作中几乎不可能有实际用途。这里拿来做演示仅仅是用于讲解重载时目标方法选择的过程，大部分情况下进行这样极端的重载都可算是真正的“关于茴香豆的茴有几种写法的研究”。无论对重载的认识有多么深刻，一个合格的程序员都不应该在实际应用中写出如此极端的重载代码。  
另外还有一点读者可能比较容易混淆：这里讲述的解析与分派这两者之间的关系并不是二选一的排它关系，他们是在不同层次上去筛选、确定目标方法的过程。例如，前面说过，静态方法会在类加载器就进行解析，而静态方法显然也是可以拥有重载版本的，选择重载版本的过程也是通过静态分派完成的。

# 动态分派（重写） #

了解了静态分派，我们接下里看一下动态分派的过程，他和多态性的另外一个重要体现——重写（Override）有着很密切的关联。我们还是用前面的Man和Woman一起sayHello的例子来讲解动态分派，请看下面代码。

/**
     * 方法动态分派演示
     *
     */
    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

这个运行结果相信不会出乎任何人的意料，对于习惯了面向对象思维的java程序员会觉得这是完全理所当然的。现在的问题还是和前面的一样，虚拟机是如何知道要调用哪个方法的？  
显然这里不可能再根据静态类型来决定，因为静态类型同样都是Human的两个变量man和woman在调用sayHello()方法时执行了不同的行为，并且变量man在两次调用中执行了不同的方法。导致这个现象的原因很明显，是这两个变量的实际类型不同，Java虚拟机是如何根据实际类型来分派方法执行版本的呢？我们使用javap命令输出这段代码的字节码，尝试从中寻找答案，输出结果如下所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VuX2pva2Vy_size_16_color_FFFFFF_t_70][]

0~15行的字节码是准备工作，作用是建立man和woman的内存空间、调用Man和Woman类型的实例构造器，将这两个实例的引用存放在第1、2个局部变量表Slot之中，这个动作就对应了代码中的这两句：

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

接下来的16~21句是关键部分，16、20两句分别把刚刚创建的两个对象引用压到栈顶，这两个对象是将要执行的sayHello()方法的所有者，称为接收者（Receiver）；17和21句是方法调用指令，这两条调用指令单从字节码角度来看，无论是指令（都是invokevirtual）还是参数（都是常量池中第22项的常量，注释显示了这个常量是Human.sayHello()的符号引用）完全一样的，但是这两句指令最终执行的目标方法并不相同。原因就需要从invokevirtual指令的多态查找过程开始说起，invokevirtual指令的运行时解析过程大致分为以下几个步骤：

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

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

# 单分派与多分派 #

方法的接收者与方法的参数统称为方法的宗量，这个定义最早应该来源于《Java与模式》一书。根据分派基于多少种宗量，可以将分派划分为单分派和多分派两种。单分派是根据一个宗量对目标方法进行选择，多分派则是根据多于一个宗量对目标方法进行选择。  
单分派和多分派的定义读起来拗口，从字面上看也比较抽象，不过对照着实例看就不难理解了。下面代码中列举了一个Father和Son一起来做出“一个艰难的决定”的例子。

/**
     * 单分派、多分派演示
     *
     */
    public class Dispatch {
    	static class QQ{}
    	static class _360{}
    	public static class Father {
    		public void hardChoice(QQ arg) {
    			System.out.println("father choose qq");
    		}
    		public void hardChoice(_360 arg) {
    			System.out.println("father choose 360");
    		}
    	}
    	public static class Son extends Father {
    		public void hardChoice(QQ arg) {
    			System.out.println("son choose qq");
    		}
    		public void hardChoice(_360 arg) {
    			System.out.println("son choose 360");
    		}
    	}
    	public static void main(String[] args) {
    		Father father = new Father();
    		Father son = new Son();
    		father.hardChoice(new _360());
    		son.hardChoice(new QQ());
    	}
    }

运行结果：

> father choose 360  
> son choose qq

在main函数中调用了两次hardChoice()方法，这两次hardChoice()方法的选择结果在程序输出中已经显示的很清楚了。  
我们来看看编译器的选择过程，也就是静态分派的过程。这时选择目标方法的依据有两点：一是静态类型是Father还是Son，二是方法参数是QQ还是360.这次选择结果的最终产物是产生了两条invokevirtual指令，两条指令的参数分别为常量池中指向Father.hardCoice(360)及Father.hardChoice(QQ)方法的符号引用。因为是根据两个宗量进行选择，所以Java语言的静态分派属于多分派类型。  
再看看运行阶段虚拟机的选择，也就是动态分派的过程。在执行“son.hardChoice(new QQ())”这句代码时，更准确地说，是在执行这句代码所对应的invokevirtual指令时，由于编译器已经决定目标方法的签名必须为hardChoice(QQ)，虚拟机此时不会关心传递过来的参数“QQ”到底是“腾讯QQ”还是“奇瑞QQ”，因为这时参数的静态类型、实际类型都对方法的选择不会够成任何影响。唯一可以影响虚拟机选择的因素只有此方法的接受者的实际类型是Father还是Son。因为只有一个宗量作为选择依据，所以Java语言的动态分派属于单分派类型。  
根据上述论证的结果，我们可以总结一句：今天的Java语言是一门静态多分派、动态单分派的语言。强调“今天的Java语言”是因为这个结论未必会恒久不变。  
按照目前Java语言的发展趋势，他并没有直接变为动态语言的迹象，而是通过内置动态语言（如javaScript）执行引擎的方式来满足动态性的需求。但是Java虚拟机层面上则不是如此，在JDK 1.7中实现的JSR-292里面就已经开始提供对动态语言的支持了，JDK 1.7中新增的invokedynamic指令也成为了最复杂的一条方法调用的字节码指令。

# 虚拟机动态分派的实现 #

前面介绍的分派过程，作为对虚拟机概念模型的解析基本上已经足够了，他已经解决了虚拟机在分派中“会做什么”这个问题。但是虚拟机“具体是如何做到的”，可能各种虚拟机的实现都会有些差别。  
由于动态分派是非常频繁的动作，而且动态分派的方法版本选择过程需要运行时在类的方法元数据中搜索合适的目标方法，因此在虚拟机的实际实现中基于性能的考虑，大部分实现都不会真正的进行如此频繁的搜索。面对这种情况，最常用的“稳定优化”手段就是为类在方法区中建立一个虚方法表（Vritual Method Table，也称为vtable，与此对应的，在invokeinterface执行时也会用到接口方法表——Inteface Method Table，简称itable），使用虚方法表索引来代替元数据查找以提高性能。我们先看看上面代码所对应的虚方法表结构示例，如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VuX2pva2Vy_size_16_color_FFFFFF_t_70 1][]

虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类中没有被重写，那子类的虚方法表里面的地址入口和父类相同方法的地址入口是一致的，都指向父类的实现入口。如果子类中重写了这个方法，子类方法表中的地址将会替换为指向子类实现版本的入口地址。上图中，Son重写了来自Father的全部方法，因此Son的方法表没有指向Father类型数据的箭头。但是Son和Father都没有重写来自Object的方法，所以他们的方法表中所有从Object继承来的方法都指向了Object的数据类型。  
为了程序实现上的方便，具有相同签名的方法，在父类、子类的虚方法表中都应当具有一样的索引序号，这样当类型变换时，仅需要变更查找的方法表，就可以从不同的虚方法表中按索引转换出所需的入口地址。  
方法表一般在类加载的连接阶段进行初始化，准备了类的变量初始值后，虚拟机会把该类的方法表也初始化完毕。  
上文中方法表是分派调用的“稳定优化”手段，虚拟机除了使用方法表之外，在条件允许的情况下，还会使用内联缓存（Inline Cache）和基于“类型继承关系分析”（Class Hierarchy Analysis，CHA）技术的守护内联（Guarded Inlining）两种非稳定的“激进优化”手段来获得更高的性能。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VuX2pva2Vy_size_16_color_FFFFFF_t_70]: /images/20220126/6f6cfc1d04294e2d8724e89aa178673a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2VuX2pva2Vy_size_16_color_FFFFFF_t_70 1]: /images/20220126/71c03bb10bb04f4e962ad4c4df4788cd.png