Java 8 Lambdas实现原理

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

       Lambda表达式到底被编译成了什么，结论是JVM会在编译时和运行时对Lambda表达式动了手脚。
       编译时：Lambda 表达式会生成一个方法， 方法实现了表达式的代码逻辑；生成invokedynamic指令，调用bootstrap方法，由java.lang.invoke.LambdaMetafactory.metafactory方法实现。
       运行时：invokedynamic指令调用metafactory方法。 它会返回一个CallSite, 此CallSite返回目标类型的一个匿名实现类， 此类关联编译时产生的方法；lambda表达式调用时会调用匿名实现类关联的方法。

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

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_SUPERConstant 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/MethodHandlesBootstrapMethods:  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();    }

这里需要六个参数，按顺序描述如下：
          1.MethodHandles.Lookup caller : 代表查找上下文与调用者的访问权限, 使用invokedynamic指令时, JVM会自动自动填充这个参数
          2. String invokedName : 要实现的方法的名字, 使用invokedynamic时, JVM自动帮我们填充(填充内容来自常量池InvokeDynamic.NameAndType.Name), 在这里JVM为我们填充为 "apply", 即Consumer.accept方法名.
          3. MethodType invokedType : 调用点期望的方法参数的类型和返回值的类型(方法signature). 使用invokedynamic指令时, JVM会自动自动填充这个参数(填充内容来自常量池InvokeDynamic.NameAndType.Type), 在这里参数为String, 返回值类型为Consumer, 表示这个调用点的目标方法的参数为String, 然后invokedynamic执行完后会返回一个即Consumer实例.
          4. MethodType samMethodType :  函数对象将要实现的接口方法类型, 这里运行时, 值为 (Object)Object 即 Consumer.accept方法的类型(泛型信息被擦除).#67 (Ljava/lang/Object;)V
          5. MethodHandle implMethod : 一个直接方法句柄(DirectMethodHandle), 描述在调用时将被执行的具体实现方法 (包含适当的参数适配, 返回类型适配, 和在调用参数前附加上捕获的参数), 在这里为 #70 invokestatic Lambda.lambda$0:(Ljava/lang/String;)V 方法的方法句柄.
          6. 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实现的内部类，这个类是在运行的时候构建的，并不会保存在磁盘中，如果想看到这个构建的类，可以通过设置环境参数：

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 4ab389fb5e490e8e0070d0b11a9c71b9final class Test$$Lambda$1 implements java.util.function.Consumer  minor version: 0  major version: 52  flags: ACC_FINAL, ACC_SUPER, ACC_SYNTHETICConstant 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里已经编译生成了一个静态的方法，内部类只需要调用该静态方法。
      留个思考问题，为什么lambda只能使用表达式外面用final修饰的变量？