jvm 指令 invokedynamic

inDy（invokedynamic）是 java 7 引入的一条新的虚拟机指令，这是自 1.0 以来第一次引入新的虚拟机指令。到了 java 8 这条指令才第一次在 java 应用，用在 lambda 表达式中。 indy 与其他 invoke 指令不同的是它允许由应用级的代码来决定方法解析。所谓应用级的代码其实是一个方法，在这里这个方法被称为引导方法（Bootstrap Method），简称 BSM。BSM 返回一个 CallSite（调用点） 对象，这个对象就和 inDy 链接在一起了。以后再执行这条 inDy 指令都不会创建新的 CallSite 对象。CallSite 就是一个 MethodHandle（方法句柄）的 holder。方法句柄指向一个调用点真正执行的方法。

理解 MethodHandle（方法句柄）的一种方式就是将其视为以安全、现代的方式来实现反射的核心功能。

一个 java 方法的实体有四个构成：

  1. 方法名
  2. 签名–参数列表和返回值
  3. 定义方法的类
  4. 方法体（代码）

同一个类中，方法名相同，签名不同，JVM 会视为不同的方法，不过在 Java 中只支持签名的参数列表部分，也就是重载多态。一次方法调用，除了要方法的实体外，还要调用者（caller）和接收者（receiver），调用者也就是方法调用语句所在的类。接收者是一个对象，每个方法调用都要一个接收者，它可以是隐藏的（this），也可以是类方法，比如： String.valueOf，类也是 Class 的一个实例。

MethodType 表示方法签名。

用 MethodHandle 实现的方法调用的示例如下，可以看到方法的四个构成：

  1. Object rcvr = "a";
  2. try {
  3. MethodType mt = MethodType.methodType(int.class); // 方法签名
  4. MethodHandles.Lookup l = MethodHandles.lookup(); // 调用者，也就是当前类。调用者决定有没有权限能访问到方法
  5. MethodHandle mh = l.findVirtual(rcvr.getClass(), "hashCode", mt); //分别是定义方法的类，方法名，签名
  7. int ret;
  8. try {
  9. ret = (int)mh.invoke(rcvr); // 代码，第一个参数就是接收者
  10. System.out.println(ret);
  11. } catch (Throwable t) {
  12. t.printStackTrace();
  13. }
  14. } catch (IllegalArgumentException | NoSuchMethodException | SecurityException e) {
  15. e.printStackTrace();
  16. } catch (IllegalAccessException x) {
  17. x.printStackTrace();
  18. }

详细可参考：

java8 lambda 表达式

lambda 表达式 是怎么使用 inDy 呢？以一段简单的代码为例

  1. public class LambdaTest {
  2. public static void main(String[] args) {
  3. Runnable r = () -> System.out.println(Arrays.toString(args));
  4. r.run();
  5. }
  6. }

用 javap -v -p LambdaTest 查看字节码，可以发现寥寥几行 java 代码生成的字节码却不少，单单常量池常量就有 66 个之多。输出见 LambdaTest.class。

可以发现多出了一个新方法，方法体就是 lambda 体（lambda body），转换为源码如下：

  1. private static void lambda$main$0(java.lang.String[] args){
  2. System.out.println(Arrays.toString(args));
  3. }

主要看一下 main 方法，并没有直接调用上面的方法，而是出现一条 inDy 指令：

  1. public static void main(java.lang.String[]);
  2. descriptor: ([Ljava/lang/String;)V
  3. flags: ACC_PUBLIC, ACC_STATIC
  4. Code:
  5. stack=1, locals=2, args_size=1
  6. 0: aload_0
  7. 1: invokedynamic #2, 0 // InvokeDynamic #0:run:([Ljava/lang/String;)Ljava/lang/Runnable;
  8. 6: astore_1
  9. 7: aload_1
  10. 8: invokeinterface #3, 1 // InterfaceMethod java/lang/Runnable.run:()V
  11. 13: return

可以看到 inDy 指向一个类型为 [CONSTANT_InvokeDynamic_info][] 的常量项 #2，另外 0 是预留参数，暂时没有作用。

  1. #2 = InvokeDynamic #0:#30 // #0:run:([Ljava/lang/String;)Ljava/lang/Runnable;

#0 表示在 Bootstrap methods 表中的索引：

  1. BootstrapMethods:
  2. 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;
  3. Method arguments:
  4. #28 ()V
  5. #29 invokestatic com/company/LambdaTest.lambda$main$0:([Ljava/lang/String;)V
  6. #28 ()V

#30 则是一个 [CONSTANT_NameAndType_info][]，表示方法名和方法类型（返回值和参数列表），这个会作为参数传递给 BSM。

  1. #30 = NameAndType #43:#44 // run:([Ljava/lang/String;)Ljava/lang/Runnable;

再看回表中的第 0 项，#27 是一个 [CONSTANT_MethodHandle_info][]，实际上是个 MethodHandle（方法句柄）对象，这个句柄指向的就是 BSM 方法。在这里就是:

  1. java.lang.invoke.LambdaMetafactory.metafactory(MethodHandles.Lookup,String,MethodType,MethodType,MethodHandle,MethodType)

BSM 前三个参数是固定的，后面还可以附加任意数量的参数，但是参数的类型是有限制的，参数类型只能是

  • String
  • Class
  • int
  • long
  • float
  • double
  • MethodHandle
  • MethodType

LambdaMetafactory.metafactory 带多三个参数，这些的参数的值由 Bootstrap methods 表 提供：

  1. Method arguments:
  2. #25 ()V
  3. #26 invokestatic com/company/LambdaTest.lambda$main$0:()V
  4. #25 ()V

inDy 所需要的数据大概就是这些，可参考 Java8学习笔记（2） – InvokeDynamic指令 - CSDN博客

inDy 运行时

每一个 inDy 指令都称为 Dynamic Call Site(动态调用点)，根据 jvm 规范所说的，inDy 可以分为两步，这两步部分代码代码是在 java 层的，给 metafactory 方法设断点可以看到一些行为。

第一步 inDy 需要一个 CallSite（调用点对象），CallSite 是由 BSM 返回的，所以这一步就是调用 BSM 方法。代码可参考：java.lang.invoke.CallSite#makeSite

调用 BSM 方法可以看作 invokevirtual 指令执行一个 invoke 方法，方法签名如下：

  1. invoke:(MethodHandle,Lookup,String,MethodType,/*其他附加静态参数*/)CallSite

前四个参数是固定的，被依次压入操作栈里

  1. MethodHandle，实际上这个方法句柄就是指向 BSM
  2. Lookup, 也就是调用者，是 Indy 指令所在的类的上下文，可以通过 Lookup#lookupClass()获取这个类
  3. name ，lambda 所实现的方法名，也就是"run"
  4. invokedType，调用点的方法签名，这里是 methodType(Runnable.class,String[].class)

接下来就是附加参数，这些参数是灵活的，由Bootstrap methods 表提供，这里分别是：

  1. samMethodType，其实就是 Runnable.run 的描述符: methodType(void.class)。sam 就 single public abstract method 的缩写
  2. implMethod: 编译器给生成的 desugar 方法，是一个 MethodHandle：caller.findStatic(LambdaTest.class,"lambda$main$0",methodType(void.class))
  3. instantiatedMethodType: Runnable.run 运行时的描述符，如果方法泛型的，那这个类型可能不一样。这里是 methodType(void.class)

上面说的固定其实应该是指 inDy 传递的实参类型是固定的，BSM 形参声明可以是随意，保证 BSM 能被调用就行，比如说 Lookup 声明为 Object 不影响调用。

接下来就是执行 LambdaMetafactory.metafactory 方法了，它会创建一个匿名类，这个类是通过 ASM 编织字节码在内存中生成的，然后直接通过 unsafe 直接加载而不会写到文件里。不过可以通过下面的虚拟机参数让它运行的时候输出到文件

  1. -Djdk.internal.lambda.dumpProxyClasses=<path>

这个类是根据 lambda 的特点生成的，输出后可以看到，在这个例子中是这样的：

  1. import java.lang.invoke.LambdaForm.Hidden;
  3. // $FF: synthetic class
  4. final class LambdaTest$$Lambda$1 implements Runnable {
  5. private final String[] arg$1;
  7. private LambdaTest$$Lambda$1(String[] var1) {
  8. this.arg$1 = var1;
  9. }
  11. private static Runnable get$Lambda(String[] var0) {
  12. return new LambdaTest$$Lambda$1(var0);
  13. }
  15. @Hidden
  16. public void run() {
  17. LambdaTest.lambda$main$0(this.arg$1);
  18. }
  19. }

然后就是创建一个 CallSite，绑定一个 MethodHandle，指向的方法其实就是生成的类中的静态方法 LambdaTest$$Lambda$1.get$Lambda(String[])Runnable。然后把调用点对象返回，到这里 BSM 方法执行完毕。

更详细的可参考：

第二步，就是执行这个方法句柄了，这个过程就像 invokevirtual 指令执行 MethodHandle#invokeExact 一样，

加上 inDy 上面那一条 aload_0 指令，这是操作数栈有两个分别是：

  1. args[]，lambda 里面调用了 main 方法的参数
  2. 调用点对象（CallSite），实际上是方法句柄。如果是 CostantCallSite 的时候，inDy 会直接跟他的方法句柄链接。见代码：MethodHandleNatives.java#L255

传入 args，执行方法，返回一个 Runnable 对象，压入栈顶。到这里 inDy 就执行完毕。

接下来的指令就很好理解，astore_1 把栈顶的 Runnable 对象放到局部变量表的槽位1，也是变量 r。剩下的就是再拿出来调用 run 方法。

Groovy

接下来看一下 groovy 是如何使用 inDy 指令的。先复习一遍 groovy 的方法派发。

每当 Groovy 调用一个方法时，它不会直接调用它，而是要求一个中间层来代替它。 中间层通过钩子方法允许我们更改方法调用的行为。这个中间层就是 MOP（meta object proctol），MOP 主要承载的类就是 MetaClass 。一个简化版的 MOP 主要有这些方法：

  • invokeMethod(String methodName, Object args)
  • methodMissing(String name, Object arguments)
  • getProperty(String propertyName)
  • setProperty(String propertyName, Object newValue)
  • propertyMissing(String name)

可以大致认为在 Groovy 中的每个方法和属性访问调用都会转化上面的方法调用。而这些方法可以在运行时通过重写修改它的默认行为，MOP 作为方法派发的中心枢纽为 Groovy 提供了非常灵活的动态编程的能力。

现在来看一下一段简短的 groovy 代码，

  1. class Test{
  2. int a = 0;
  3. static void main(args){
  4. Test wtf = new Test()
  5. wtf.a
  6. wtf.doSomething()
  7. }
  8. }

通过 groovyc -indy Test.groovy 把它编译成字节码。 indy 选项的意思就是启用 invokedynamic 支持。

看一下编译后的 main 方法。

  1. public static void main(java.lang.String...);
  2. descriptor: ([Ljava/lang/String;)V
  3. flags: ACC_PUBLIC, ACC_STATIC, ACC_VARARGS
  4. Code:
  5. stack=1, locals=2, args_size=1
  6. 0: ldc #2 // class Test
  7. 2: invokedynamic #44, 0 // InvokeDynamic #0:init:(Ljava/lang/Class;)Ljava/lang/Object;
  8. 7: invokedynamic #50, 0 // InvokeDynamic #1:cast:(Ljava/lang/Object;)LTest;
  9. 12: astore_1
  10. 13: aload_1
  11. 14: pop
  12. 15: aload_1
  13. 16: invokedynamic #56, 0 // InvokeDynamic #2:getProperty:(LTest;)Ljava/lang/Object;
  14. 21: pop
  15. 22: aload_1
  16. 23: invokedynamic #61, 0 // InvokeDynamic #3:invoke:(LTest;)Ljava/lang/Object;
  17. 28: pop
  18. 29: return

可以看到一共有 4 条 inDy 指令，包括构造函数，访问成员变量，和不存在的方法调用都是 通过 invokedynamic 实现的。

再看一下引导方法表

  1. BootstrapMethods:
  2. 0: #38 invokestatic org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
  3. Method arguments:
  4. #39 <init>
  5. #40 0
  6. 1: #38 invokestatic org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
  7. Method arguments:
  8. #46 ()
  9. #40 0
  10. 2: #38 invokestatic org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
  11. Method arguments:
  12. #51 a
  13. #52 4
  14. 3: #38 invokestatic org/codehaus/groovy/vmplugin/v7/IndyInterface.bootstrap:(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;Ljava/lang/String;I)Ljava/lang/invoke/CallSite;
  15. Method arguments:
  16. #58 doSomething
  17. #40 0

可以发现所有 inDy 指令的引导方法都是 IndyInterface.bootstrap

以方法调用的 inDy 指令为例，它的方法名称是 “invoke”，方法签名是 methodType(Object.class,Test.class)，BSM 方法还附带两个参数分别是实际的方法名："doSomething" 和一个标志：0

BSM 方法最终调用的是 realBootstrap 方法：

  1. private static CallSite realBootstrap(Lookup caller, String name, int callID, MethodType type, boolean safe, boolean thisCall, boolean spreadCall) {
  2. MutableCallSite mc = new MutableCallSite(type); //这里是 MutableCallSite，lambda 表达式用的是 ConstantCallSite
  3. MethodHandle mh = makeFallBack(mc,caller.lookupClass(),name,callID,type,safe,thisCall,spreadCall);
  4. mc.setTarget(mh);
  5. return mc;
  6. }

主要的代码是调用 makeFallBack 来获取一个临时的 MethodHandle。因为在第一步 groovy 无法确定接收者（receiver），也是就是 invoke 方法的第一个实参（Test 实例），必须要在第二步确定 CallSite 后才会传递过来。所以方法解析要放在第二步。

  1. protected static MethodHandle makeFallBack(MutableCallSite mc, Class<?> sender, String name, int callID, MethodType type, boolean safeNavigation, boolean thisCall, boolean spreadCall) {
  2. MethodHandle mh = MethodHandles.insertArguments(SELECT_METHOD, 0, mc, sender, name, callID, safeNavigation, thisCall, spreadCall, /*dummy receiver:*/ 1); //MethodHandle(Object.class,Object[].class)
  3. mh = mh.asCollector(Object[].class, type.parameterCount()).
  4. asType(type);
  5. return mh;
  6. }

这个 fallback 方法其实就是 selectMethod。insertArguments 在这里主要做了一个柯里化的操作，因为selectMethod 的方法签名是

  1. methodType(Object.class, MutableCallSite.class, Class.class, String.class, int.class, Boolean.class, Boolean.class, Boolean.class, Object.class, Object[].class)

而 inDy 要求的方法签名却是

  1. methodType(Object.class,Test.class)。

所以得经过 insertArguments 的变换，把确定的值填充进去，用最后的数组参数来接收 inDy 传递的参数。这样这个方法就能够被 inDy 调用了。第一步创建 CallSite 到这里就结束。

第二步，就是 selectMethod 方法的调用，这时候 groovy 已经知道方法的接收者 arguments[0]，

  1. public static Object selectMethod(MutableCallSite callSite, Class sender, String methodName, int callID, Boolean safeNavigation, Boolean thisCall, Boolean spreadCall, Object dummyReceiver, Object[] arguments) throws Throwable {
  2. Selector selector = Selector.getSelector(callSite, sender, methodName, callID, safeNavigation, thisCall, spreadCall, arguments);
  3. selector.setCallSiteTarget();
  5. MethodHandle call = selector.handle.asSpreader(Object[].class, arguments.length);
  6. call = call.asType(MethodType.methodType(Object.class,Object[].class));
  7. return call.invokeExact(arguments);
  8. }

首先创建一个方法解析器，在这里是 MethodSelector。接着调用 setCallSiteTarget()，这个方法就是用来解析实际的方法。具体的过程还是很复杂的，所以也没法说清楚，大体来说就是确定接收者的 MetaClass，决定这个方法是实际的方法，还是交给 MetaClass 的钩子方法，然后就是创建这个方法的 MethodHandle，然后把这个 MethodHandle 的签名转化为要求的签名。这时 selecor.handle 就是最终调用的方法句柄了。接下来就是最终的方法调用了，到这里 inDy 指令就执行完毕了。

还有一个方法值得留意：

  1. public void doCallSiteTargetSet() {
  2. if (!cache) {
  3. if (LOG_ENABLED) LOG.info("call site stays uncached");
  4. } else {
  5. callSite.setTarget(handle);
  6. if (LOG_ENABLED) LOG.info("call site target set, preparing outside invocation");
  7. }
  8. }

这也是为什么用 MutableCallSite 的原因，如果编译器认为这个方法是可以缓存，那么就会把这个 CallSite 绑定到实际的 MethodHandle，后续的调用就不用再重新解析了。

最后

没有相关经验，inDy 还是很不好理解的，学习了 java 8 和 groovy 对 inDy 的应用才有一点大致的认识，文中如果有什么错误，还请帮忙指出。

posted @ 2021-07-29 10:54  方东信  阅读(413)  评论(0)  编辑  收藏  举报