Java8 Lambdas实现原理

Posted on 2024-03-05 In Java , Java进阶

Lambda表达式到底被编译成了什么，JVM会在编译时和运行时对Lambda表达式动手脚。

编译时：Lambda 表达式会生成一个方法，方法实现了表达式的代码逻辑；生成invokedynamic指令，调用bootstrap方法，由java.lang.invoke.LambdaMetafactory.metafactory方法实现。
运行时：invokedynamic指令调用metafactory方法。它会返回一个CallSite, 此CallSite返回目标类型的一个匿名实现类，此类关联编译时产生的方法；lambda表达式调用时会调用匿名实现类关联的方法。

下面来个简单的ambda表达式的例子：

import java.util.function.Consumer;
public class Test {
	public static void main(String[] args) {
		Consumer<String> c = s -> System.out.println(s);
		c.accept("hello lambda");
	}
}

使用javap查看生成的字节码 javap -c -p -v Test.class:

Classfile /Test.class
  Last modified Jun 23, 2017; size 1057 bytes
  MD5 checksum eab4179ef0e9aed7da4c1dd221300e1f
  Compiled from "Test.java"
public class Test
  minor version: 0
  major version: 52
  flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
   #1 = Methodref          #8.#19         // java/lang/Object."<init>":()V
   #2 = InvokeDynamic      #0:#25         // #0:accept:()Ljava/util/function/Consumer;
   ......
{
  public Test();
    descriptor: ()V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #1                  // Method java/lang/Object."<init>":()V
         4: return
      LineNumberTable:
        line 3: 0

  public static void main(java.lang.String[]);
    descriptor: ([Ljava/lang/String;)V
    flags: ACC_PUBLIC, ACC_STATIC
    Code:
      stack=2, locals=2, args_size=1
         0: invokedynamic #2,  0              // InvokeDynamic #0:accept:()Ljava/util/function/Consumer;
         5: astore_1
         6: aload_1
         7: ldc           #3                  // String hello lambda
         9: invokeinterface #4,  2            // InterfaceMethod java/util/function/Consumer.accept:(Ljava/lang/Object;)V
        14: return
      LineNumberTable:
        line 5: 0
        line 6: 6
        line 7: 14

  private static void lambda$main$0(java.lang.String);
    descriptor: (Ljava/lang/String;)V
    flags: ACC_PRIVATE, ACC_STATIC, ACC_SYNTHETIC
    Code:
      stack=2, locals=1, args_size=1
         0: getstatic     #5                  // Field java/lang/System.out:Ljava/io/PrintStream;
         3: aload_0
         4: invokevirtual #6                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
         7: return
      LineNumberTable:
        line 5: 0
}
SourceFile: "Test.java"
InnerClasses:
     public static final #52= #51 of #55; //Lookup=class java/lang/invoke/MethodHandles$Lookup of class java/lang/invoke/MethodHandles
BootstrapMethods:
  0: #21 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:
      #22 (Ljava/lang/Object;)V
      #23 invokestatic Test.lambda$main$0:(Ljava/lang/String;)V
      #24 (Ljava/lang/String;)V

第41行可以看出来，Lambda表达式体被生成一个称之为lambda$main$0的方法，它调用System.out.println输出传入的参数。在main方法中，原lambda表达式处产生了一条invokedynamic #2, 0，#2也就是后面的注释InvokeDynamic #0:accept:()Ljava/util/function/Consumer，0 是占位符号，无用。

每一个invokedynamic指令的实例叫做一个动态调用点(dynamic call site), 动态调用点最开始是未链接状态(unlinked:表示还未指定该调用点要调用的方法), 动态调用点依靠引导方法来链接到具体的方法。

引导方法是由编译器生成，在运行期当JVM第一次遇到invokedynamic指令时, 会调用引导方法来将invokedynamic指令所指定的名字(方法名,方法签名)和具体的执行代码(目标方法)链接起来，引导方法的返回值永久的决定了调用点的行为。引导方法的返回值类型是java.lang.invoke.CallSite，一个invokedynamic指令关联一个CallSite, 将所有的调用委托到CallSite当前的target(MethodHandle)。

找到#2 = InvokeDynamic #0:#25 表示要执行 #0 处的指令，#0 位置即BootstrapMethods：

BootstrapMethods:
  0: #21 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:
      #22 (Ljava/lang/Object;)V
      #23 invokestatic Test.lambda$main$0:(Ljava/lang/String;)V
      #24 (Ljava/lang/String;)V

Lambda表达式具体的转换是通过java.lang.invoke.LambdaMetafactory.metafactory实现的，静态参数依照lambda表达式和目标类型不同而不同。来看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();
}

这里需要六个参数，按顺序描述如下：

MethodHandles.Lookup caller : 代表查找上下文与调用者的访问权限, 使用invokedynamic指令时, JVM会自动自动填充这个参数
String invokedName : 要实现的方法的名字, 使用invokedynamic时, JVM自动帮我们填充(填充内容来自常量池InvokeDynamic.NameAndType.Name), 在这里JVM为我们填充为 “apply”, 即Consumer.accept方法名.
MethodType invokedType : 调用点期望的方法参数的类型和返回值的类型(方法signature). 使用invokedynamic指令时, JVM会自动自动填充这个参数(填充内容来自常量池InvokeDynamic.NameAndType.Type), 在这里参数为String, 返回值类型为Consumer, 表示这个调用点的目标方法的参数为String, 然后invokedynamic执行完后会返回一个即Consumer实例.
MethodType samMethodType : 函数对象将要实现的接口方法类型, 这里运行时, 值为 (Object)Object 即 Consumer.accept方法的类型(泛型信息被擦除).#67 (Ljava/lang/Object;)V
MethodHandle implMethod : 一个直接方法句柄(DirectMethodHandle), 描述在调用时将被执行的具体实现方法 (包含适当的参数适配, 返回类型适配, 和在调用参数前附加上捕获的参数), 在这里为 #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 方法的方法句柄.
MethodType instantiatedMethodType : 函数接口方法替换泛型为具体类型后的方法类型, 通常和 samMethodType 一样, 不同的情况为泛型。比如函数接口方法定义为 void accept(T t) T为泛型标识, 这个时候方法类型为(Object)Void, 在编译时T已确定, 即T由String替换, 这时samMethodType就是 (Object)Void, 而instantiatedMethodType为(String)Void。

第4, 5, 6 三个参数来自class文件中的，如上面引导方法字节码中Method arguments后面的三个参数就是将应用于4, 5, 6的参数：

Method arguments:
  #22 (Ljava/lang/Object;)V
  #23 invokestatic Test.lambda$main$0:(Ljava/lang/String;)V
  #24 (Ljava/lang/String;)V

metafactory返回的CallSite实际是由InnerClassLambdaMetafactory的buildCallSite来生成。生成之前会调用validateMetafactoryArgs方法校验目标类型(SAM)方法的参数/和产生的方法的参数/返回值类型是否一致。InnerClassLambdaMetafactory.buildCallSite方法如下：

CallSite buildCallSite() throws LambdaConversionException {
       final Class<?> innerClass = spinInnerClass();
       if (invokedType.parameterCount() == 0) {
		..... //调用构造函数初始化一个SAM的实例
           return new ConstantCallSite(MethodHandles.constant(samBase, inst));
       } else {
           UNSAFE.ensureClassInitialized(innerClass);
               return new ConstantCallSite(
                       MethodHandles.Lookup.IMPL_LOOKUP
                            .findStatic(innerClass, NAME_FACTORY, invokedType));
       }
   }

函数spinInnerClass 构建了这个内部类，也就是生成了一个Lambda$$Lambda$1/716157500 这样的内部类,这个类是在运行的时候构建的，并不会保存在磁盘中，如果想看到这个构建的类，可以通过设置环境参数

其中spinInnerClass调用asm框架动态的产生SAM实现的内部类，这个类是在运行的时候构建的，并不会保存在磁盘中，如果想看到这个构建的类，可以通过设置环境参数：

1	System.setProperty("jdk.internal.lambda.dumpProxyClasses", ".");

会在指定的路径”.”即当前运行路径上生成这个内部类。这个实现类的的方法将会调用编译时产生的那个实现方法，即lambda$main$0。

现在将这个内部类生成在磁盘上，代码里加上参数后运行Test.class，在目录上会多了Test$$Lambda$1.class文件，javap -p -v Test$$Lambda$1.class：

Classfile /Test$$Lambda$1.class
  Last modified Jun 23, 2017; size 392 bytes
  MD5 checksum 4ab389fb5e490e8e0070d0b11a9c71b9
final class Test$$Lambda$1 implements java.util.function.Consumer
  minor version: 0
  major version: 52
  flags: ACC_FINAL, ACC_SUPER, ACC_SYNTHETIC
Constant pool:
   #1 = Utf8               Test$$Lambda$1
   ……
{
  private Test$$Lambda$1();
    descriptor: ()V
    flags: ACC_PRIVATE
    Code:
      stack=1, locals=1, args_size=1
         0: aload_0
         1: invokespecial #10                 // Method java/lang/Object."<init>":()V
         4: return

  public void accept(java.lang.Object);
    descriptor: (Ljava/lang/Object;)V
    flags: ACC_PUBLIC
    Code:
      stack=1, locals=2, args_size=2
         0: aload_1
         1: checkcast     #15                 // class java/lang/String
         4: invokestatic  #21                 // Method Test.lambda$main$0:(Ljava/lang/String;)V
         7: return
    RuntimeVisibleAnnotations:
      0: #13()
}

这个类implements实现了Consumer接口，accept方法实际上调用了Test.lambda$main$0静态函数，也就是表达式中的函数块。

如果，使用的是方法引用

public static void main(String[] args) throws Throwable {
	Consumer<String> c  = System.out::println;
	c.accept("hello");
}

这段代码是不会产生一个类似” lambda$main$0”新方法。因为LambdaMetafactory会直接使用这个引用的方法。

总结

使用invokedynamic指令，运行时调用LambdaMetafactory.metafactory动态的生成内部类，实现了接口，内部类里的调用方法块并不是动态生成的，只是在原class里已经编译生成了一个静态的方法，内部类只需要调用该静态方法

参考：
http://colobu.com/2014/11/06/secrets-of-java-8-lambda/
http://blog.csdn.net/raintungli/article/details/54910152