JVM 之虚拟机栈之方法调用（详细）

最新推荐文章于 2024-10-08 13:01:25 发布

Clare丶Diane

最新推荐文章于 2024-10-08 13:01:25 发布

阅读量441

点赞数 1

分类专栏： JVM虚拟机栈文章标签： java

本文链接：https://blog.csdn.net/qq_41826542/article/details/124447767

版权

JVM虚拟机栈专栏收录该内容

6 篇文章 1 订阅

订阅专栏

1. 基本概念

方法调用并不等同于方法中的代码被执行，方法调用阶段唯一的任务就是确定被调用方法的版本(即调用哪个方法)，暂时还未涉及方法内部的具体运行过程。在程序运行时，进行方法调用是最普遍、最频繁的操作之一，Class 文件的编译过程除遇到任中不包含传统程序语言编译的连接步骤，一切方法调用在Class文件里面存储的都只是符号引用，而不是方法在实际运行时内存布局中的人口地址(也就是之前说的直接引用)。

这个根据遇特性给Java带来了更强大的动态扩展能力，但也使得Java方法调用过程变得相对复杂，某些调用需要在类加载期间，甚至到运行期间才能确定目标方法的直接引用。

1.1 静态链接

当一个字节码文件被装载进 JVM 内部时，如果被调用的目标方法在编译期可知，且运行期间保持不变时，将调用方法的符号引用转换为直接引用的过程称为静态链接。

1.2 动态链接

如果被调用的方法在编译期无法被确定下来，也就是说，只能够在程序运行期将调用方法的符号引用转换成直接引用。由于这种转换过程具备动态性，因此也被称之为动态链接。

对应的方法的绑定机制为：早期绑定（Early Binding）和晚期绑定（Late Binding）。绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，该过程仅仅发生一次。

1.2.1 早期绑定

早期绑定就是指被调用的目标方法如果在编译期可知，且运行期间保持不变时，即可将这个方法与所属的类型进行绑定。这样一来，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用。

1.2.2 晚期绑定

如果被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关方法，这种绑定方式也被称之为晚期绑定。

2 解析

承接前面关于方法调用的话题，所有方法调用的目标方法在Class文件里面都是一个常量池中的符号引用，在类加载的解析阶段，会将其中的一部分符号引用转化为直接引用。这种解析能够成立的前提是：方法在程序真正运行之前就有一个可确定的调用版本，并且这个方法的调用版本在运行期是不可改变的。换句话说，调用目标在程序代码写好、编译器进行编译的那一刻就已经确定下来了。这类方法的调用被称为解析。
在Java语言中符合“编译期可知，运行外部不可被访问"这个要去的方法，主要有静态方法和私有方法，前者与类型直接关联，后者在外部不可被访问，这两点决定了它们都不可能通过继承或别的方式重写出其他版本，因此它们都适合在类加载阶段进行解析。

     如果方法在编译期就确定了具体的调用版本，这个版本在运行时是不可变的，这样的方法叫非虚方法。

静态方法、私有方法、final 方法、实例构造器、父类方法都是非虚方法。

其他方法称为虚方法。

        调用不同类型的方法，字节码指令集里设计了不不同的指令。在Java虚拟机支持以下5条方法调用字节码指令，分别是:
        invokestatic 用于调用静态方法。
invokesepecial 用于调用实例构造器<init>()方法、私有方法和父类中的方法。
        invokevirtual 用于调用所有的虚方法。
        invokeinterface 用于调用接口方法，会在运行时再确定一个实现该接口的对象。
        invokedynamic 先在运行时动态解析出调用点限定符所引用的方法，然后再执行该方法。

        前面4条调用指令，分派逻辑都固化在Java虚拟机内部，方法的调用执行不可人为干预，而invokedynamic指令的分派逻辑是由用户设定的引导方法来决定的。

        只要能被invokestatic 和invokesepecial 指令调用的方法，都可以在解析阶段中确定唯一的调用版本，Java 语言里符合这个条件的方法共有静态方法、私有方法、实例构造器、父类方法4种，再加上被final修饰的方法(尽管它使用invokevirtual指令调用)，这5种方法
调用会在类加载的时候就可以把符号引用解析为该方法的直接引用。这些方法统称为“非虚方法"(Non-Virual Method)，与之相反，其他方法就被称为“虚方法”(Virtual Method)。

Java中的非虚方法除了使用invokestatic、invokespecial 调用的方法之外还有一种，就是被final修饰的实例方法。虽然由于历史设计的原因，final 方法是使用invokevirtual指令来调用的，但是因为它也无法被覆盖，没有其他版本的可能，所以也无须对方法接收者进行多态选择，又或者说多态选择的结果肯定是唯一的。在《Java语言规范》中明确定义了被final修饰的方法是一种非虚方法。
解析调用一定是个静态的过程，在编译期间就完全确定，在类加载的解析阶段就会把涉及的符号引用全部转变为明确的直接引用，不必延迟到运行期再去完成。而另一种主要的方法调用形式:分派(Dispatch)调用则要复杂许多，它可能是静态的也可能是动态的，按照分派依据的宗量数可分为单分派和多分派。这两类分派方式两两组合就构成了静态单分派、静态多分派、动态单分派、动态多分派4种分派组合情况，下面我们来看看虚拟机中的方法分派是如何进行的。

3 分派

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

3.1 静态分派

在开始讲解静态分派前，笔者先声明一点，“分派”(Dispatch)这个词本身就具有动态性，一般不应用在静态语境之中，这部分原本在英文原版的《Java虚拟机规范》和《Java语言规范》里的说法都是“Method Overload Resolution”，即应该归入8.2节的“解析”里去讲解，但部分其他外文资料和国内翻译的许多中文资料都将这种行为称为“静态分派”。

首先来看一段代码：

    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();
        TestStaticDispatch testStaticDispatch =new TestStaticDispatch();
        testStaticDispatch.sayHello(man);
        testStaticDispatch.sayHello(woman);
    }

运行结果如下：

hello,guy!
hello,guy!

Humanlan = new Man() ;
我们把上面代码中的“Human"称为变量的“静态类型”( Static Type),或者叫“外观类型"(Apparent Type), 后面的“Man”则被称为变量的“实际类型”(Actual Type)或者叫运行时类(RuntimeType)。

静态类型和实际类型在程序中都可能会发生变化，区别是静态类型的变化仅仅在使用时发生，变量本身的静态类型不会被改变，并且最终的静态刑是在编译期可知的；而实际类型变化的结果在运行期才可确定，编译器在编译程序的时候并不知道一个对象的实际类型是什么。笔者猜想上面这段话读者大概会不太好理解，那不妨通过一段实际例子来解释，譬如有下面的代码:

         // 实际类型变化
        Human human = (new Random() ) . nextBoolean()? newMan() : new woman() ;
        //静态类型变化
        sr. sayHello( (Man) human)
        sr. sayHello( (Woman) human)

        对象human的实际类型是可变的，编译期间它完全是个“薛定谔的人”，到底是Man还是Woman,必须等到程序运行到这行的时候才能确定。而human的静态类型是Human,也可以在使用时(如sayHello()方法中的强制转型)临时改变这个类型，但这个改变仍是在编译期是可知的，两次sayHello()方法的调用，在编译期完全可以明确转型的是Man还是Woman。
        解释清楚了静态类型与实际类型的概念，我们就把话题再转回到代码中。main() 里面的两次sayHello() 方法调用，在方法接收者已经确定是对象“testStaticDispatch”的前提下，使用哪个重载版本，就完全取决于传人参数的数量和数据类型。代码中故意定义了两个静态类型相同，而实际类型不同的变量，但虚拟机(或者准确地说是编译器)在重载时是通过参数的静态类型而不是实际类型作为判定依据的。由于静态类型在编译期可知，所以在编译阶段，Javac编译器就根据参数的静态类型决定了会使用哪个重载版本，因此选择了sayHello(Human)作为调用目标，并把这个方法的符号引用写到main()方法里的两条invokevirtual 指令的参数中。
        所有依赖静态类型来决定方法执行版本的分派动作，都称为静态分派。静态分派的最典型应用表现就是方法重载。静态分派发生在编译阶段，因此确定静态分派的动作实际上不是由虚拟机来执行的，这点也是为何一些资料选择把它归人“解析”而不是“分派”的原因。需要注意javac 编译器虽然能确定出方法的重载版本，但在很多情况下这个重载版本并不是“唯一”的，往往只能确定一个“相对更合适的"版本。

重载方法匹配优先级

    public static void syaHello(Object arg){
        System.out.println("hello object");
    }
    public static void syaHello(int arg){
        System.out.println("hello int");
    }
    public static void syaHello(long arg){
        System.out.println("hello long");
    }
    public static void syaHello(char arg){
        System.out.println("hello char");
    }
    public static void syaHello(Character arg){
        System.out.println("hello Character");
    }
    public static void syaHello(Serializable arg){
        System.out.println("hello Serializable");
    }
    public static void syaHello(char... arg){
        System.out.println("hello char...");
    }

    public static void main(String[] args) {
        syaHello('a');
    }

上面代码会输出：hello char

变体1：注释掉 public static void syaHello(char arg)方法，结果为 hello int

解释1：这时发生了一次自动类型转换，‘a’除了可以代表一个字符串。话可以代表数字97。因此参数类型为int的重载也是合适的。

变体2：我们继续注释掉sayHello(int arg)方法，那输出会变为: hello long

解释2：这时发生了两次自动类型转换。‘a’转型为整数97之后，进一步转型为长整数97L，匹
配了参数类型为long的重载。实际上自动转型还能继续发生多次，按照char > int > long > float > double的顺序转型进行匹配，但不会匹配到byte和short类型的重载，因为char到byte或short的转型是不安全的。

变体3：我们继续注释掉sayHello(long arg)方法，那输出会变为: hello Character

解释3：这时发生了一次自动装箱，‘a’被包装为它的封装类型java lang.Character,所以匹配到了参数类型为Character的重载。

变体4：继续注释掉sayHello(Character arg)方法，那输出会变为:hello Serlalizable

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

变体5：下面继续注释掉sayHello(Serializable arg)方法，输出会变为: hello object

解释5：这时是char装箱后转型为父类了，如果有多个父类，那将在继承关系中从下往上开始搜索，越接上层的优先级越低。即使方法调用传入的参数值为null时，这个规则仍然适用。

变体6：我们把sayHello(Object arg)也注释掉，输出将会变为: hello char...

解释6：7个重载方法已经被注释得只剩I个了，可见变长参数的重载优先级是最低的，这时候字符'a‘’被当作了一个char[]数组的元素。

总结：代码演示了编译期间选择静态分派目标的过程，这个过程也是Java语言实现方法重载的本质。演示所用的这段程序无疑是属于很极端的例子，演示仅仅是用于讲解重载时目标方法选择的过程。

3.2 动态分派

了解了静态分派，我们接下来看一下Java语言里动态分派的实现过程，它与Java 语言
多态性的另外一个重要体现-------重写 (Override)有着很密切的关联。我们还是用前面的Man和Woman一起sayHello的例子来讲解动态分派。

   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反编译得到：

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class 虚拟机栈/TestDynamicDispatch$Man
       3: dup
       4: invokespecial #3                  // Method 虚拟机栈/TestDynamicDispatch$Man."<init>":()V
       7: astore_1
       8: new           #4                  // class 虚拟机栈/TestDynamicDispatch$Woman
      11: dup
      12: invokespecial #5                  // Method 虚拟机栈/TestDynamicDispatch$Woman."<init>":()V
      15: astore_2
      16: aload_1
      17: invokevirtual #6                  // Method 虚拟机栈/TestDynamicDispatch$Human.sayHello:()V
      20: aload_2
      21: invokevirtual #6                  // Method 虚拟机栈/TestDynamicDispatch$Human.sayHello:()V
      24: new           #4                  // class 虚拟机栈/TestDynamicDispatch$Woman
      27: dup
      28: invokespecial #5                  // Method 虚拟机栈/TestDynamicDispatch$Woman."<init>":()V
      31: astore_1
      32: aload_1
      33: invokevirtual #6                  // Method 虚拟机栈/TestDynamicDispatch$Human.sayHello:()V
      36: return

        0~15行的字节码是准备动作，作用是建立man和woman的内存空间、调用Man和Woman类型的实例构造器，将这两个实例的引用存放在第1、2个局部交量表的变量槽中，这些动作实际对应了Java源码中的这两行:
        Human man = new Man():
        Human woman = new Woman();

接下来的16~21行是关键部分。

16 和20行的aload指令分别把刚刚创建的两个对象的引用压到栈顶，这两个对象是将要执行的syHello方法的所有者，称为接收者(receiver);

        17和21行是方法调用指令，这两条调用指令单从字节码角度来看，无论是指令(invokevirtual)还是参数(都是常量池中第22项的常量，注释显示了这个常量是Human.sayHello()的符号引用)都完全一样，但是这两句指令最终执行的目标方法并不相同。关键还必须从invokevirtual指令本身入手，要弄清楚它是如何确定调用方法版本、如何实现多态查找来着手分析才行。根据《Java虚拟机规范》，invokevirtual指令的运行时解析过程大致分为以下几步:
        1)找到操作数栈顶的第一个元素所指向的对象的实际类型，记作C。
        2)如果在类型C中找到与常量中的描述符和简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束;不通过则返回java.lang.IllegalAccessError异常。

3)否则，按照继承关系从下往上依次对C的各个父类进行第二步的搜索和验证过程。

4)如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError异常。

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

既然这种多态性的根源在于虚方法调用指令invokevirtual的执行逻辑，那自然我们得出的结论就只会对方法有效，对字段是无效的，因为字段不使用这条指令。事实上，在Java里面只有虚方法存在，字段永远不可能是虚的，换句话说，字段永远不参与多态，哪个类的方法访问某个名字的字段时，该名字指的就是这个类能看到的那个字段。当子类声明了与父类同名的字段时，虽然在子类的内存中两个字段都会存在，但是子类的字段会遮蔽父类的同名字段。

3.3 单分派与多分派

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

举例：

public class TestDispatch {
    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:hardChoice(360)及Father:hardChoice(QQ)方法的符号引用。因为是根据两个宗量进行选择，所以Java语言的静态分派属于多分派类型。

再看看运行阶段中虚拟机的选择，也就是动态分派的过程。在执“son.hardChoice(newQQ())”这行代码时，更准确地说，是在执行这行代码所对应的invokevirtual指令时，由于编译期已经决定目标方法的签名必须为hardChoice(QQ),虚拟机此时不会关心传递过来的参数“QQ”到底是“腾讯QQ”还是“奇瑞QQ”，因为这时候参数的静态类型、实际类型都对方法的选择不会构成任何影响，唯- 可以影响虚拟机选择的因素只有该方法的接受者的实际类型是Father还是Son。因为只有宗量作为选择依据，所以java语言的动态分派属于单分派类型。

3.4 虚拟机动态分派的实现

动态分派是执行非常频繁的动作，而且动态分派的方法版本选择过程需要运行时在接收者类型的方法元数据中搜索合适的目标方法，因此，Java虚拟机实现基于执行性能的考虑，真正运行时一般不会如此频繁地去反复搜索类型元数据。面对这种情况，一种基础而且常见的优化手段是为类型在方法区中建立一个虚方法表( Virtual Method Table,也称为 vtable,与此对应的，invokeinterface执行时也会用到接口方法表---Interface Method Table,简称itable),使用虚方法表索引来代替元数据查找以提高性能。

虚方法表中存放着各个方法的实际入口地址。如果某个方法在子类中没有被重写，那子类的虚方法表中的地址人口和父类相同方法的地址入口是一致的，都指向父类的实现入口。如果子类中重写了这个方法，子类虚方法表中的地址也会被替换为指向子类实现版本的入口地址。

为了程序实现方便，具有相同签名的方法，在父类、子类的虚方法表中都应当具有一样的索引序号，这样当类型变换时，仅需要变更查找的虚方法表，就可以从不同的虚方法表中按索引转换出所需的人口地址。虚方法表一般在类加载的连接阶段进行初始化，准备了类的变量初始值后，虚拟机会把该类的虚方法表也一同初始化完毕。

查虚方法表是分派调用的一种优化手段，由于Java对象里面的方法默认(即不使用final修饰)就是虚方法，虚拟机除了使用虚方法表之外，为了进一步提高性能，还会使用类型继承关系分析( Class Hierarchy Analysis, CHA)、守护内联( Guarded Inlining)、内联缓存(Inline Cache)等多种非稳定的激进优化来争取更大的性能空间。