JVM字节码之字节码指令二

• 方法的静态绑定与动态绑定
• 方法调用指令

方法调用指令

方法调用指令有5种

• invokestatic 调用静态方法
• invokespecial 调用私有实例方法, 构造器, 以及使用super关键字调用父类的实例方法或者构造器和所实现接口的默认方法.
• invokevirtual 调用非私有方法
• invokeinterface 调用接口方法
• invokedynamic 调用动态方法

invokestatic例子

public class Main {
    public static void main(String[] args) {
        A.test();
    }
}

class A {
    public static String test() {
        return "A test";
    }
}

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
    stack=1, locals=1, args_size=1
        0: invokestatic  #2                  // Method com/yuda/test/A.test:()Ljava/lang/String;
        3: pop
        4: return
    LineNumberTable:
    line 10: 0
    line 11: 4
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0       5     0  args   [Ljava/lang/String;

invokespecial例子

public class Main extends A{
    public static void main(String[] args) {

    }
    public void testM (){
        super.test();
        testM2();
        new A();
        super.run();
    }
    private void testM2(){

    }
}

class A implements Runnable{
    public String test() {
        return "A test";
    }

    @Override
    public void run() {

    }
}

public void testM();
descriptor: ()V
flags: ACC_PUBLIC
Code:
    stack=2, locals=1, args_size=1
        0: aload_0
        1: invokespecial #2                  // Method com/yuda/test/A.test:()Ljava/lang/String;
        4: pop
        5: aload_0
        6: invokespecial #3                  // Method testM2:()V
        9: new           #4                  // class com/yuda/test/A
    12: dup
    13: invokespecial #1                  // Method com/yuda/test/A."<init>":()V
    16: pop
    17: aload_0
    18: invokespecial #5                  // Method com/yuda/test/A.run:()V
    21: return
    LineNumberTable:
    line 13: 0
    line 14: 5
    line 15: 9
    line 16: 17
    line 17: 21
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0      22     0  this   Lcom/yuda/test/Main;

invokevirtual例子

public class Main{
    public static void main(String[] args) {

    }

    public void testM(A a) {
        a.test();
    }
}

class A {
    public String test() {
        return "A test";
    }
}

public void testM(com.yuda.test.A);
descriptor: (Lcom/yuda/test/A;)V
flags: ACC_PUBLIC
Code:
    stack=1, locals=2, args_size=2
        0: aload_1
        1: invokevirtual #2                  // Method com/yuda/test/A.test:()Ljava/lang/String;
        4: pop
        5: return
    LineNumberTable:
    line 14: 0
    line 15: 5
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0       6     0  this   Lcom/yuda/test/Main;
        0       6     1     a   Lcom/yuda/test/A;

invokeinterface例子

public class Main {
    public static void main(String[] args) {

    }

    public void testM(A a) {
        a.run();
    }
}

class A implements Runnable {
    @Override
    public void run() {

    }
}

public void testM(com.yuda.test.A);
descriptor: (Lcom/yuda/test/A;)V
flags: ACC_PUBLIC
Code:
    stack=1, locals=2, args_size=2
        0: aload_1
        1: invokevirtual #2                  // Method com/yuda/test/A.run:()V
        4: return
    LineNumberTable:
    line 14: 0
    line 15: 4
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0       5     0  this   Lcom/yuda/test/Main;
        0       5     1     a   Lcom/yuda/test/A;

invokedynamic例子

public class Main {
    public static void main(String[] args) {
        Function<String, String> stringStringFunction = Main::apply;
    }

    private static String apply(String i) {
        return i;
    }
}

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
    stack=1, locals=2, args_size=1
        0: invokedynamic #2,  0              // InvokeDynamic #0:apply:()Ljava/util/function/Function;
        5: astore_1
        6: return
    LineNumberTable:
    line 13: 0
    line 14: 6
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0       7     0  args   [Ljava/lang/String;
        6       1     1 stringStringFunction   Ljava/util/function/Function;
    LocalVariableTypeTable:
    Start  Length  Slot  Name   Signature
        6       1     1 stringStringFunction   Ljava/util/function/Function<Ljava/lang/String;Ljava/lang/String;>;

静态绑定与动态绑定

• 静态绑定 : 在编译时时能确定目标方法 invokestatic, invokespecial
• 动态绑定 : 需要在运行时根据调用者的类型动态识别 invokevirtual, invokeinterface, invokedynamic

invokevirtual，invokeinterface

invokevirtual，invokeinterface 功能上类似, 都是执行一个方法, 但是invokevirtual用来调用对象的方法，invokeinterface用来调用接口的方法. JVM是从效率上考虑这件事的, 要想方法执行快, 就要快速找到这个方法, 每个类文件都关联着一个虚方法表(virtual method table), 这个记录了每个方法的位置信息. 例如A,B类有继承关系, B继承了A, B的虚方法表和A的虚方法表对应, 如果B覆盖了A的某个方法, 只用改变B虚方法表相应位置的函数链接引用就可以了, 如果B新加了方法, 只用在B的虚方法表后面增加相应的记录即可.

invokevirtual 做了这样的优化: 它可以通过虚方法表的index, 来找到需要执行的方法.
invokeinterface 是针对接口的方法, 由于接口相对于继承的区别, 这种优化在接口上无法实现, 例如: B继承了A, B同时实现了X接口, C仅实现了X接口, 那么B和C的虚方法表中对于接口的方法, 就无法通过位置关系对应起来.

• Java 子类会继承父类的 vtable。Java 所有的类都会继承 java.lang.Object 类，Object 类有 5 个虚方法可以被继承和重写。当一个类不包含任何方法时，vtable 的长度也最小为 5，表示 Object 类的 5 个虚方法
• final 和 static 修饰的方法不会被放到 vtable 方法表里
• 当子类重写了父类方法，子类 vtable 原本指向父类的方法指针会被替换为子类的方法指针
• 子类的 vtable 保持了父类的 vtable 的顺序

invokedynamic

其余4个指令, 都把方法的定位规则固化到了虚拟机内部, 而invokedynamic开放了限制, 如何定位方法交给用户代码去决定. 流程如下:

1. 首次执行invokedynamic指令时, 会执行一个引导方法.
2. 引导方法返回一个CallSite对象, 其内部进行方法的定位, 返回一个MethodHandler对象, 可以重复使用MethodHandler对象
3. CallSite对象发生变化后, 将会重新执行定位方法的操作, 这些都在运行期进行.

public class Main {
    public static void main(String[] args) {
        Function<String, String> stringStringFunction = Main::apply;
    }

    private static String apply(String i) {
        return i;
    }
}

....略
#25 = Utf8               Main.java
#26 = NameAndType        #5:#6          // "<init>":()V
#27 = Utf8               BootstrapMethods
#28 = MethodHandle       #6:#35         // invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#29 = MethodType         #36            //  (Ljava/lang/Object;)Ljava/lang/Object;
#30 = MethodHandle       #6:#37         // invokestatic com/yuda/test/Main.apply:(Ljava/lang/String;)Ljava/lang/String;
#31 = MethodType         #21            //  (Ljava/lang/String;)Ljava/lang/String;
#32 = NameAndType        #20:#38        // apply:()Ljava/util/function/Function;
#33 = Utf8               com/yuda/test/Main
#34 = Utf8               java/lang/Object
#35 = Methodref          #39.#40        // java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#36 = Utf8               (Ljava/lang/Object;)Ljava/lang/Object;
#37 = Methodref          #3.#41         // com/yuda/test/Main.apply:(Ljava/lang/String;)Ljava/lang/String;
#38 = Utf8               ()Ljava/util/function/Function;
#39 = Class              #42            // java/lang/invoke/LambdaMetafactory
#40 = NameAndType        #43:#47        // metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#41 = NameAndType        #20:#21        // apply:(Ljava/lang/String;)Ljava/lang/String;
#42 = Utf8               java/lang/invoke/LambdaMetafactory
#43 = Utf8               metafactory
#44 = Class              #49            // java/lang/invoke/MethodHandles$Lookup
#45 = Utf8               Lookup
#46 = Utf8               InnerClasses
#47 = Utf8               (Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
#48 = Class              #50            // java/lang/invoke/MethodHandles
#49 = Utf8               java/lang/invoke/MethodHandles$Lookup
#50 = Utf8               java/lang/invoke/MethodHandles

....略

public static void main(java.lang.String[]);
descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
    stack=1, locals=2, args_size=1
        0: invokedynamic #2,  0              // InvokeDynamic #0:apply:()Ljava/util/function/Function;
        5: astore_1
        6: return
    LineNumberTable:
    line 13: 0
    line 14: 6
    LocalVariableTable:
    Start  Length  Slot  Name   Signature
        0       7     0  args   [Ljava/lang/String;
        6       1     1 stringStringFunction   Ljava/util/function/Function;
    LocalVariableTypeTable:
    Start  Length  Slot  Name   Signature
        6       1     1 stringStringFunction   Ljava/util/function/Function<Ljava/lang/String;Ljava/lang/String;>;

....略

InnerClasses:
     public static final #45= #44 of #48; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #28 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #29 (Ljava/lang/Object;)Ljava/lang/Object;
      #30 invokestatic com/yuda/test/Main.apply:(Ljava/lang/String;)Ljava/lang/String;
      #31 (Ljava/lang/String;)Ljava/lang/String;

lambda表达式

lambda表达式写法很像匿名内部类的语法糖写法, 但是他们是不同的, lambda表达式是使用invokedynamic指令完成的.

public class Main {
    public static void main(String[] args) {
        Runnable r = () -> {
            System.out.println("hello, lambda");
        };
        r.run();
    }
}

如下:

...略
  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=1, locals=2, args_size=1
         0: invokedynamic #2,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
         5: astore_1
         6: aload_1
         7: invokeinterface #3,  1            // InterfaceMethod java/lang/Runnable.run:()V
        12: return
      LineNumberTable:
        line 10: 0
        line 13: 6
        line 14: 12
      LocalVariableTable:
        Start  Length  Slot  Name   Signature
            0      13     0  args   [Ljava/lang/String;
            6       7     1     r   Ljava/lang/Runnable;

  private static void lambda$main$0();
    descriptor: ()V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=0, args_size=0
         0: getstatic     #4                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: ldc           #5                  // String hello, lambda
         5: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         8: return
      LineNumberTable:
        line 11: 0
        line 12: 8
}
SourceFile: "Main.java"
InnerClasses:
     public static final #57= #56 of #60; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #27 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;
    Method arguments:
      #28 ()V
      #29 invokestatic com/yuda/test/Main.lambda$main$0:()V
      #28 ()V

可以看到他和 java/lang/invoke/LambdaMetafactory 中的 metafactory 方法有点关系. 方法如下:

public static CallSite metafactory(MethodHandles.Lookup caller,
                                    String invokedName,
                                    MethodType invokedType,
                                    MethodType samMethodType,
                                    MethodHandle implMethod,
                                    MethodType instantiatedMethodType)
        throws LambdaConversionException {
    AbstractValidatingLambdaMetafactory mf;
    mf = new InnerClassLambdaMetafactory(caller, invokedType,
                                            invokedName, samMethodType,
                                            implMethod, instantiatedMethodType,
                                            false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
    mf.validateMetafactoryArgs();
    return mf.buildCallSite();
}

• caller：表示具有调用者的可访问权限的查找上下文。当与 invokedynamic 一起使用时，它会被虚拟机自动堆叠。
• invokedName：要实现的方法的名称。当与 invokedynamic 一起使用时，它由 invokedynamic 结构的 NameAndType 提供，并由虚拟机自动堆叠。
• invokedType：预期的 CallSite 的签名。参数类型表示捕获变量的类型;返回类型是要实现的接口。当与 invokedynamic 一起使用时，它由 invokedynamic 结构的 NameAndType 提供，并由虚拟机自动堆叠。如果实现方法是一个实例方法，并且该签名有任何参数，则调用签名中的第一个参数必须与接收方对应。
• samMethodType：由函数对象实现的方法的签名和返回类型
• implMethod：一个直接方法句柄，描述在调用时应该调用的实现方法(参数类型、返回类型的适当调整，以及在调用参数之前包含捕获的参数)。
• instantiatedMethodType：应该在调用时动态执行的签名和返回类型。这可能与samMethodType相同，也可能是它的专门化。

lambdaClassName就是新生成的一个类com/yuda/test/Main$$Lambda$1的类名. 类中一个方法包含了#29 invokestatic com/yuda/test/Main.lambda$main$0:()V 调用了 com/yuda/test/Main中的lambda$main$0()方法.

1. lambda 表达式声明的地方会生成一个 invokedynamic 指令，同时编译器生成一个对应的引导方法（Bootstrap Method）.
2. 第一次执行 invokedynamic 指令时，会调用对应的引导方法（Bootstrap Method），该引导方法会调用 LambdaMetafactory.metafactory 方法动态生成内部类.
3. 引导方法会返回一个动态调用 CallSite 对象，这个 CallSite 会链接最终调用的实现了 Runnable 接口的内部类.
4. lambda 表达式中的内容会被编译成静态方法，前面动态生成的内部类会直接调用该静态方法.
5. 真正执行 lambda 调用的还是用 invokeinterface 指令. ————- from 掘金小册