源码学习 | Java 8 Lambda实现原理分析（源码层面）

关于 Lambda 表达式的使用请参考：JDK 8 新特性 | Lambda 表达式

先来定义一个 Lambda 表达式的样例：

package Lambda表达式.实现原理分析;

@FunctionalInterface
interface Print<T> {
    public void print(T x);
}

package Lambda表达式.实现原理分析;

public class Lambda {
    public static void PrintString(String s, Print<String> print) {
        print.print(s);
    }

    public static void main(String[] args) {
        PrintString("test", (x) -> System.out.println(x));
    }
}

然后反编译一下生成的 Class 文件：

$ javap -p Lambda.class // -p 表示输出所有类及成员

Compiled from "Lambda.java"

public class Lambda表达式.实现原理分析.Lambda {
  public Lambda表达式.实现原理分析.Lambda();
  public static void PrintString(java.lang.String, Lambda表达式.实现原理分析.Print<java.lang.String>);
  public static void main(java.lang.String[]);
  private static void lambda$0(java.lang.String);
}

由上面的代码可以看出编译器会根据 Lambda 表达式生成一个私有的静态函数，注意，在这里说的是生成，而不是等价。

private static void lambda$0(java.lang.String);

为了验证上面的转化是否正确? 我们在代码中定义一个lambda$0这个的函数，最终代码如下所示：

package Lambda表达式.实现原理分析;

public class Lambda {
    public static void PrintString(String s, Print<String> print) {
        print.print(s);
    }

    private static void lambda$0(String s) {
    }

    public static void main(String[] args) {
        PrintString("test", (x) -> System.out.println(x));
    }
}

上面的代码在编译时不会报错，但是运行时就会报错，因为存在两个lambda$0函数，如下所示，是运行时的错误：

Exception in thread "main" java.lang.ClassFormatError: Duplicate method name&signature in class file Lambda表达式/实现原理分析/Lambda
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:142)
    at java.net.URLClassLoader.defineClass(URLClassLoader.java:467)
    at java.net.URLClassLoader.access$100(URLClassLoader.java:73)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:368)
    at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
    at java.security.AccessController.doPrivileged(Native Method)
    at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:335)
    at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
    at sun.launcher.LauncherHelper.checkAndLoadMain(LauncherHelper.java:495)

通过javap对上述错误代码进行反编译，反编译之后输出的类的成员如下所示：

$ javap -p Lambda.class

Compiled from "Lambda.java"

public class Lambda表达式.实现原理分析.Lambda {
  public Lambda表达式.实现原理分析.Lambda();
  public static void PrintString(java.lang.String, Lambda表达式.实现原理分析.Print<java.lang.String>);
  private static void lambda$0(java.lang.String);
  public static void main(java.lang.String[]);
  private static void lambda$0(java.lang.String);
}

会发现lambda$0出现了两次，那么在代码运行的时候，就不知道去调用哪个，因此就会抛错。

有了上面的内容，可以知道的是Lambda表达式在Java 8中首先会生成一个私有的静态函数，这个私有的静态函数干的就是Lambda表达式里面的内容,因此上面的代码初步可以转化成如下所示的代码：

package Lambda表达式.实现原理分析;

public class Lambda {
    public static void PrintString(String s, Print<String> print) {
        print.print(s);
    }

    private static void lambda$0(String s) {
        System.out.println(x);
    }

    public static void main(String[] args) {
        PrintString("test", /**lambda expression**/);
    }
}

转化成上面的形式之后，那么如何实现调用静态的lambda$0函数呢，在这里可以在以下方法打上断点，可以发现在有Lambda表达式的地方，运行时会进入这个函数：

package java.lang.invoke;

public final class LambdaMetafactory {
    ...

    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();                                                     
    }       
    ...                                                                           
}                                                                                   

在这个函数中可以发现为 Lambda 表达式生成了一个内部类，为了验证是否生成内部类，可以在代码中加上一下代码：

System.setProperty("jdk.internal.lambda.dumpProxyClasses", "D://");

运行时，会将生成的内部类 class 码输出到指定的路径下。

$ javap -p Lambda\$\$Lambda\$1.class  // "\"是转义符号

final class Lambda表达式.实现原理分析.Lambda$$Lambda$1 implements Lambda表达式.实现原理分析.Print {
  private Lambda表达式.实现原理分析.Lambda$$Lambda$1();
  public void print(java.lang.Object);
}

如果运行javap -c -p，则结果如下

$ javap -c -p Lambda\$\$Lambda\$1.class

final class Lambda表达式.实现原理分析.Lambda$$Lambda$1 implements Lambda表达式.实现原理分析.Print {
  private Lambda表达式.实现原理分析.Lambda$$Lambda$1();
    Code:
       0: aload_0
       1: invokespecial #10                 // Method java/lang/Object."<init>":()V
       4: return

  public void print(java.lang.Object);
    Code:
       0: aload_1
       1: checkcast     #15                 // class java/lang/String
       4: invokestatic  #21                 // Method Lambda表达式/实现原理分析/Lambda.lambda$0:(Ljava/lang/String;)V
       7: return
}

通过上面的字节码指令可以发现实现上调用的是Lambda.lambda$0这个私有的静态方法

因此最终的Lambda表达式等价于以下形式：

public class Lambda {   
    public static void PrintString(String s, Print<String> print) {
        print.print(s);
    }
    private static void lambda$0(String x) {
        System.out.println(x);
    }
    final class $Lambda$1 implements Print{
        @Override
        public void print(Object x) {
            lambda$0((String)x);
        }
    }
    public static void main(String[] args) {
        PrintString("test", new Lambda().new $Lambda$1());
    }
}