JVM方法调用的那些事

时间 2019-11-06

标签 jvm 方法调用那些栏目 Java 繁體版

原文原文链接

前言

Java具有三种特性：封装、继承、多态。java

Java文件在编译过程当中不会进行传统编译的链接步骤，方法调用的目标方法以符号引用的方式存储在Class文件中，这种多态特性给Java带来了更灵活的扩展能力，但也使得方法调用变得相对复杂，须要在类加载期间，甚至到运行期间才能肯定目标方法的直接引用。jvm

方法调用

全部方法调用的目标方法在Class文件里面都是常量池中的符号引用。在类加载的解析阶段，若是一个方法在运行以前有肯定的调用版本，且在运行期间不变，虚拟机会将其符号引用解析为直接调用。ide

这种 编译期可知，运行期不可变 的方法，主要包括静态方法和私有方法两大类，前者与具体类直接关联，后者在外部不可访问，二者都不能经过继承或别的方式进行重写性能

JVM提供了以下方法调用字节码指令：spa

invokestatic：调用静态方法；
invokespecial：调用实例构造方法<init>，私有方法和父类方法；
invokevirtual：调用虚方法；
invokeinterface：调用接口方法，在运行时再肯定一个实现此接口的对象；
invokedynamic：在运行时动态解析出调用点限定符所引用的方法以后，调用该方法；

经过invokestatic和invokespecial指令调用的方法，能够在解析阶段肯定惟一的调用版本，符合这种条件的有静态方法、私有方法、实例构造器和父类方法4种，它们在类加载时会把符号引用解析为该方法的直接引用。code

invokestatic

public class VirtualTest {
    public static void hello() {
        System.out.println("hello");
    }
    public static void main(String[] args) {
        hello();
    }
}

经过javap命令查看main方法字节码对象

public class com.jvm.VirtualTest {
  public com.jvm.VirtualTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void hello();
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String hello
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void main(java.lang.String[]);
    Code:
       0: invokestatic  #5                  // Method hello:()V
       3: return
}

能够发现hello方法是经过invokestatic指令调用的。blog

invokespecial

class VirtualTest {
    private int id;
    public static void main(String args[]) {
        new VirtualTest();
    }
}

public class com.jvm.VirtualTest {
  public com.jvm.VirtualTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/jvm/VirtualTest
       3: dup
       4: invokespecial #3                  // Method "<init>":()V
       7: pop
       8: return
}

能够发现实例构造器是经过invokespecial指令调用的经过invokestatic和invokespecial指令调用的方法，能够称为非虚方法，其他状况称为虚方法，不过有一个特例，即被final关键字修饰的方法，虽然使用invokevirtual指令调用，因为它没法被覆盖重写，因此也是一种非虚方法继承

非虚方法的调用是一个静态的过程，因为目标方法只有一个肯定的版本，因此在类加载的解析阶段就能够把符合引用解析为直接引用，而虚方法的调用是一个分派的过程，有静态也有动态，可分为静态单分派、静态多分派、动态单分派和动态多分派。接口

静态分派

静态分派发生在代码的编译阶段。

public class StaticDispatch {
    static abstract class Humnan {}
    static class Man extends Humnan {}
    static class Woman extends Humnan {}
    public void hello(Humnan guy) {
        System.out.println("hello, Humnan");
    }

    public void hello(Man guy) {
        System.out.println("hello, Man");
    }

    public void hello(Woman guy) {
        System.out.println("hello, Woman");
    }

    public static void main(String[] args) {
        Humnan man = new Man();
        Humnan woman = new Woman();
        StaticDispatch dispatch = new StaticDispatch();
        dispatch.hello(man);
        dispatch.hello(woman);
    }
}

运行结果

hello, Humnan
hello, Humnan

相信有经验的同窗看完代码后就能得出正确的结果，但为何会这样呢？先看看main方法的字节码指令

public class com.jvm.StaticDispatch {
  public com.jvm.StaticDispatch();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public void hello(com.jvm.StaticDispatch$Humnan);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #3                  // String hello, Humnan
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public void hello(com.jvm.StaticDispatch$Man);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #5                  // String hello, Man
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public void hello(com.jvm.StaticDispatch$Woman);
    Code:
       0: getstatic     #2                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #6                  // String hello, Woman
       5: invokevirtual #4                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #7                  // class com/jvm/StaticDispatch$Man
       3: dup
       4: invokespecial #8                  // Method com/jvm/StaticDispatch$Man."<init>":()V
       7: astore_1
       8: new           #9                  // class com/jvm/StaticDispatch$Woman
      11: dup
      12: invokespecial #10                 // Method com/jvm/StaticDispatch$Woman."<init>":()V
      15: astore_2
      16: new           #11                 // class com/jvm/StaticDispatch
      19: dup
      20: invokespecial #12                 // Method "<init>":()V
      23: astore_3
      24: aload_3
      25: aload_1
      26: invokevirtual #13                 // Method hello:(Lcom/jvm/StaticDispatch$Humnan;)V  //重点在这里
      29: aload_3
      30: aload_2
      31: invokevirtual #13                 // Method hello:(Lcom/jvm/StaticDispatch$Humnan;)V  //重点在这里比较这两行
      34: return
}

经过字节码指令，能够发现两次hello方法都是经过invokevirtual指令进行调用，并且调用的是参数为Human类型的hello方法。

Humnan man = new Man();

上述代码中，变量man拥有两个类型，一个静态类型Human，一个实际类型Man，静态类型在编译期间可知。
在编译阶段，Java编译器会根据参数的静态类型决定调用哪一个重载版本，但在有些状况下，重载的版本不是惟一的，这样只能选择一个“更加合适的版本”进行调用，因此不建议在实际项目中使用这种模糊的方法重载。

动态分派

在运行期间根据参数的实际类型肯定方法执行版本的过程称为动态分派，动态分派和多态性中的重写（override）有着紧密的联系。

public class DynamicDispatch {
    static abstract class Humnan {
        abstract void say();
    }
    static class Man extends Humnan {
        @Override
        void say() {
            System.out.println("hello, i'm Man");
        }
    }
    static class Woman extends Humnan {
        @Override
        void say() {
            System.out.println("hello, i'm Woman");
        }
    }

    public static void main(String[] args) {
        Humnan man = new Man();
        Humnan woman = new Woman();
        man.say();
        woman.say();
    }
}

运行结果：

hello, i'm Man
hello, i'm Woman

对于习惯了面向对象思惟的同窗对于这个结果应该是理所固然的。这种状况下，显然不能再根据静态类型来决定方法的调用了，致使不一样输出结果的缘由很简单，man和woman的实际类型不一样，可是JVM如何根据实际类型决定须要调用哪一个方法？

main方法的字节码指令

public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class com/jvm/DynamicDispatch$Man
       3: dup
       4: invokespecial #3                  // Method com/jvm/DynamicDispatch$Man."<init>":()V
       7: astore_1
       8: new           #4                  // class com/jvm/DynamicDispatch$Woman
      11: dup
      12: invokespecial #5                  // Method com/jvm/DynamicDispatch$Woman."<init>":()V
      15: astore_2
      16: aload_1
      17: invokevirtual #6                  // Method com/jvm/DynamicDispatch$Humnan.say:()V
      20: aload_2
      21: invokevirtual #6                  // Method com/jvm/DynamicDispatch$Humnan.say:()V
      24: return
}

字节码0 ~ 15行对应如下代码：

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

在Java堆上申请内存空间和实例化对象，并将这两个实例的引用分别存放到局部变量表的第一、2位置的Slot中。

字节码16~21行对应如下代码：

man.say();
woman.say();

16和20行指令分别把以前存放到局部变量表一、2位置的对象引用压入操做数栈的栈顶，这两个对象是执行say方法的接收者（Receiver），17和21行指令进行方法调用。

能够发现，17和21两条指令彻底同样，但最终执行的目标方法却不相同，这得从invokevirtual指令的多态查找提及了，invokevirtual指令在运行时分为如下几个步骤：

找到操做数栈的栈顶元素所指向的对象的实际类型，记为C；
若是C中存在描述符和简单名称都相符的方法，则进行访问权限验证，若是验证经过，则直接返回这个方法的直接引用，不然返回java.lang.IllegalAccessError异常；
若是C中不存在对应的方法，则按照继承关系对C的各个父类进行第2步的操做；
若是各个父类也没对应的方法，则返回异常；

因此上述两次invokevirtual指令将相同的符号引用解析成了不一样对象的直接引用，这个过程就是Java语言中重写的本质。

JVM动态分派实现

因为动态分派是很是频繁的动做，所以在虚拟机的实际实现中，会基于性能的考虑，并不会如此频繁的搜索对应方法，通常会在方法区中创建一个虚方法表，使用虚方法表代替方法查询以提升性能。

虚方法表在类加载的链接阶段进行初始化，存放着各个方法的实际入口地址，若是某个方法在子类中没有被重写，那么子类的虚方法表中该方法的入口地址和父类保持一致。

abstract class Humnan {
    abstract void say();
    void run() {
        System.out.println("Human is run");
    }
}
class Man extends Humnan {
    @Override
    void say() {
        System.out.println("hello, i'm Man");
    }

    @Override
    void run() {
        System.out.println("Man is run");
    }
}
class Woman extends Humnan {
    @Override
    void say() {
        System.out.println("hello, i'm Humnan");
    }
}

对应的虚方法表结构

因为在Woman类中没有重写run方法，所以在Woman的虚方法表中，run方法直接指向Human实例