Java虚拟机学习：方法调用的字节码指令

Dear 丶 2021-09-19 03:18 382阅读 0赞

f6e1bc686388bce36663d268155645ab4368e27d

我们在写java程序的时候会进行各种方法调用，虚拟机在执行这些调用的时候会用到不同的字节码指令，共有如下五种：

**1. invokespecial：调用私有实例方法；

  1. invokestatic：调用静态方法；
  2. invokevirtual：调用实例方法；
  3. invokeinterface：调用接口方法;
  4. invokedynamic：调用动态方法；**

这里我们通过一个实例将这些方法调用的字节码指令逐个列出。

说到这里，也给大家推荐一个架构交流学习群：835544715，里面会分享一些资深架构师录制的视频录像：有Spring，MyBatis，Netty源码分析，高并发、高性能、分布式、微服务架构的原理，JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源，相信对于已经工作和遇到技术瓶颈的码友，在这个群里会有你需要的内容。

实例共两个java文件，一个是接口另一个是类，先看接口源码，很简单只有一个方法声明：

  1. package com.bolingcavalry;public interface Action {
  4.    void doAction();
  6. }

接下来的类实现了这个接口，而且还有自己的共有、私有、静态方法：

  1. package com.bolingcavalry;public class Test001 implements Action{
  4.    private int add(int a, int b){
  7.        return a+b;
  9.    }
  12.    public String getValue(int a, int b){
  15.        return String.valueOf(add(a,b));
  17.    }
  20.    public static void output(String str){
  23.        System.out.println(str);
  25.    }
  28.    @Override    public void doAction() {
  31.        System.out.println("123");
  33.    }
  36.    public static void main(String[] args){
  39.        Test001 t = new Test001();
  41.        Action a = t;
  43.        String str = t.getValue(1,2);
  45.        t.output(str);
  47.        t.doAction();
  49.        a.doAction();
  51.    }
  54.    public void createThread(){
  57.        Runnable r = () -> System.out.println("123");
  59.    }
  61. }

小结一下，Test001的代码中主要的方法如下：

  1. 一个私有方法add；
  2. 一个公有方法getValue，里面调用了add方法；
  3. 一个静态方法output；
  4. 实现接口定义的doAction；
  5. 一个公有方法，里面使用了lambda表达式；
  6. main方法中，创建对象，调用getValue，output，doAction；

接下来我们通过javac命令或者ide工具得到Action.class和Test001.class文件，如果是用intellij idea，可以先把Test001运行一遍，然后在工程目录下找到out文件夹，打开后里面是production文件夹，再进去就能找到对应的package和class文件了，如下图：

640?tp=webp&wxfrom=5&wx\_lazy=1&wx\_co=1

打开命令行，在Test001.class目录下执行javap -c Test001.class
，就可以对class文件进行反汇编，得到结果如下：

  1. Compiled from "Test001.java"public class com.bolingcavalry.Test001 implements com.bolingcavalry.Action {
  4.   public com.bolingcavalry.Test001();
  6.    Code:
  8.       0: aload_0
  10.       1: invokespecial #1                  
  12.       4: return
  15.  public java.lang.String getValue(int, int);
  17.    Code:
  19.       0: aload_0
  21.       1: iload_1
  23.       2: iload_2
  25.       3: invokespecial #2                  
  27.       6: invokestatic  #3                  
  29.       9: areturn
  32.  public static void output(java.lang.String);
  34.    Code:
  36.       0: getstatic     #4                  
  38.       3: aload_0
  40.       4: invokevirtual #5                  
  42.       7: return
  45.  public void doAction();
  47.    Code:
  49.       0: getstatic     #4                  
  51.       3: ldc           #6                  
  53.       5: invokevirtual #5                  
  55.       8: return
  58.  public static void main(java.lang.String[]);
  60.    Code:
  62.       0: new           #7                  
  64.       3: dup
  66.       4: invokespecial #8                  
  68.       7: astore_1
  70.       8: aload_1
  72.       9: astore_2
  74.      10: aload_1
  76.      11: iconst_1
  78.      12: iconst_2
  80.      13: invokevirtual #9                  
  82.      16: astore_3
  84.      17: aload_1
  86.      18: pop
  88.      19: aload_3
  90.      20: invokestatic  #10                 
  92.      23: aload_1
  94.      24: invokevirtual #11                 
  96.      27: aload_2
  98.      28: invokeinterface #12,  1           
  100.      33: returnpublic void createThread();
  102.    Code:
  104.       0: invokedynamic #13,  0             
  106.       5: astore_1
  108.       6: return}

现在我们可以对比反汇编结果来学习字节码的用法了：

invokespecial：调用私有实例方法

getValue()方法中调用了私有实例方法add(int a, int b)，反编译结果如下所示，注意编号为3的那一行：

  1. public java.lang.String getValue(int, int);
  3.    Code:
  5.       0: aload_0
  7.       1: iload_1
  9.       2: iload_2
  11.       3: invokespecial #2                  
  13.       6: invokestatic  #3                  
  15.       9: areturn

可见私有实例方法的调用是通过invokespecial指令来实现的；

invokestatic：调用静态方法

getValue()方法中，调用了静态方法String.valueOf()，反编译结果如下所示，注意编号为6的那一行：

  1. public java.lang.String getValue(int, int);
  3.    Code:
  5.       0: aload_0
  7.       1: iload_1
  9.       2: iload_2
  11.       3: invokespecial #2                  
  13.       6: invokestatic  #3                  
  15.       9: areturn

可见静态方法的调用是通过invokestatic指令来实现的；

invokevirtual：调用实例方法

在main()方法中，调用了t.getValue(1,2)方法，反编译结果如下所示，注意编号为13的那一行：

  1. public static void main(java.lang.String[]);
  3.    Code:
  5.       0: new           #7                  
  7.       3: dup
  9.       4: invokespecial #8                  
  11.       7: astore_1
  13.       8: aload_1
  15.       9: astore_2
  17.      10: aload_1
  19.      11: iconst_1
  21.      12: iconst_2
  23.      13: invokevirtual #9                  
  25.      16: astore_3
  27.      17: aload_1
  29.      18: pop
  31.      19: aload_3
  33.      20: invokestatic  #10                 
  35.      23: aload_1
  37.      24: invokevirtual #11                 
  39.      27: aload_2
  41.      28: invokeinterface #12,  1           
  43.      33: return}

可见调用一个实例的方法的时候，通过invokevirtual指令来实现的；

invokeinterface：调用接口方法

在main()方法中，我们声明了接口Action a，然后调用了a.doAction()，反编译结果如下所示，注意编号为28的那一行：

  1. public static void main(java.lang.String[]);
  3.    Code:
  5.       0: new           #7                  
  7.       3: dup
  9.       4: invokespecial #8                  
  11.       7: astore_1
  13.       8: aload_1
  15.       9: astore_2
  17.      10: aload_1
  19.      11: iconst_1
  21.      12: iconst_2
  23.      13: invokevirtual #9                  
  25.      16: astore_3
  27.      17: aload_1
  29.      18: pop
  31.      19: aload_3
  33.      20: invokestatic  #10                 
  35.      23: aload_1
  37.      24: invokevirtual #11                 
  39.      27: aload_2
  41.      28: invokeinterface #12,  1           
  43.      33: return}

可见调用一个接口的方法是通过invokeinterface指令来实现的；
其实t.doAction()和a.doAction()最终都是调用Test001的实例的doAction，但是t的声明是类，a的声明是接口，所以两者的调用指令是不同的；

invokedynamic：调用动态方法

在main()方法中，我们声明了一个lambda() -> System.out.println(“123”)，反编译的结果如下：

  1. 0: invokedynamic #13,  0             
  3.       5: astore_1
  5.       6: return
  6. 1

可见lambda表达式对应的实际上是一个invokedynamic调用，具体的调用内容，可以用Bytecode viewer这个工具来打开Test001.class再研究，由于反编译后得到invokedynamic的操作数是#13，我们先去常量池看看13对应的内容：

16c0f716068493496587aa96a076517a590b47f5

是个Name and type和Bootstrap method，再细看Bootstrap method的操作数，如下图：

72b7a217165bbef11aed8a212d11a1e685f551ce

是个MethodHandler的引用，指向了用户实现的lambda方法；

以上就是五种方法调用的字节码指令的简单介绍，实际上每个指令背后都对应着更复杂的调用和操作，有兴趣的读者可以通过虚拟机相关的书籍和资料继续深入学习。

想要学习Java高架构、分布式架构、高可扩展、高性能、高并发、性能优化、Spring boot、Redis、ActiveMQ、Nginx、Mycat、Netty、Jvm大型分布式项目实战学习架构师视频免费获取 架构群：835544715

发表评论

表情：
评论列表 （有 0 条评论，382人围观）

还没有评论，来说两句吧...

相关阅读