【源码分析】Java中的lambda表达式会生成内部类吗？是如何生成的？-摩杜云开发者社区

文末附结论

分析

以该程序为例子

public class LambdaTest {

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            System.out.println("asdwerwerwe");
        });
        t1.start();
        System.out.println("end!!!");
    }
}

调用javap -c -p LambdaTest.class之后得到：

Compiled from "LambdaTest.java"
public class com.atguigu.juc.test.LambdaTest {
  public com.atguigu.juc.test.LambdaTest();
    Code:
       0: aload_0
       1: invokespecial #1                  // Method java/lang/Object."<init>":()V
       4: return

  public static void main(java.lang.String[]);
    Code:
       0: new           #2                  // class java/lang/Thread
       3: dup
       4: invokedynamic #3,  0              // InvokeDynamic #0:run:()Ljava/lang/Runnable;
       9: invokespecial #4                  // Method java/lang/Thread."<init>":(Ljava/lang/Runnable;)V
      12: astore_1
      13: aload_1
      14: invokevirtual #5                  // Method java/lang/Thread.start:()V
      17: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
      20: ldc           #7                  // String end!!!
      22: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
      25: return

  private static void lambda$main$0();
    Code:
       0: getstatic     #6                  // Field java/lang/System.out:Ljava/io/PrintStream;
       3: ldc           #9                  // String asdwerwerwe
       5: invokevirtual #8                  // Method java/io/PrintStream.println:(Ljava/lang/String;)V
       8: return
}

在编译阶段，Java编译器将Lambda表达式转换为一个私有的静态方法，即lambda$main$0方法。
invokedynamic #3, 0其实就是把生成的lambda$main$0方法与实际的调用点进行绑定。

invokedynamic字节码会在运行时根据引导方法和方法类型来动态地解析和绑定方法的调用。
具体的动态调用逻辑由引导方法决定，在Lambda表达式的情况下，引导方法通常由LambdaMetafactory提供，用于创建函数式接口的实例并与Lambda表达式绑定。
invokedynamic #3, 0 表示在这里使用引导方法（常量池中索引为3）和方法类型（索引为0）进行动态调用。

而#3是常量池中的符号引用，对应的是bootstrap引导方法

这一串字符表示LambdaMetafactory生成的方法描述符（Method Descriptor）。在Java字节码中，方法描述符用于描述方法的参数类型和返回类型。

(Ljava/lang/invoke/MethodHandles$Lookup;：该部分表示方法的第一个参数类型，即MethodHandles.Lookup类型的参数。MethodHandles.Lookup是Java核心库中的一个类，用于执行动态方法调用。 Ljava/lang/String;：表示方法的第二个参数类型，即String类型的参数。 Ljava/lang/invoke/MethodType;：表示方法的第三个参数类型，即MethodType类型的参数。MethodType是Java核心库中的一个类，用于描述方法的类型信息，包括参数类型和返回类型。 Ljava/lang/invoke/MethodType;：表示方法的第四个参数类型，与第三个参数类型相同。 Ljava/lang/invoke/MethodHandle;：表示方法的第五个参数类型，即MethodHandle类型的参数。MethodHandle是Java核心库中的一个类，用于执行方法调用。 Ljava/lang/invoke/MethodType;)：表示方法的最后一个参数类型，即MethodType类型的参数。

那我们把视角转向LambdaMetafactory.metafactory()

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

在这个方法里打个断点以debug模式运行，从下图可以看到根据相关的信息创建了一个InnerClassLambdaMetafactory工厂对象，然后利用工厂对象进行创建，但是还是不能明确的看到创建了内部类。

【源码分析】Java中的lambda表达式会生成内部类吗？是如何生成的？_字节码_02