Lambda 表达式 / `InvokeDynamic` / `LambdaMetafactory` 源码精读

概述

Lambda 表达式不生成匿名内部类，而是靠字节码指令 invokedynamic + 引导方法 LambdaMetafactory 在运行期动态生成实现类。这让 Lambda 零额外类文件、可被 JIT 优化，还能序列化（SerializedLambda）。理解 invokedynamic、MethodHandle、LambdaForm，才算真正看懂了 Java 8 的函数式基石。本文基于 OpenJDK 21 源码拆解。

一、`invokedynamic` 指令的调用点

字节码视角（javap -v 查看）：

Lambda 源码：
  Runnable r = () -> System.out.println("hi");

编译产物：
  0: invokedynamic #7, 0  // InvokeDynamic #0:run:()Ljava/lang/Runnable;
       BootstrapMethods:
         0: #27 invokestatic java/lang/invoke/LambdaMetafactory.metafactory:
            (MethodHandles$Lookup; String; MethodType;
             MethodType; MethodHandle; MethodType)CallSite
            Method arguments:
              #28 ()V
              #29 invokestatic LambdaTest.lambda$main$0:()V
              #30 ()V

invokedynamic 关键结构：
  CONSTANT_InvokeDynamic_info（常量池）：
    指向 BootstrapMethods 属性中的一个引导方法
  BootstrapMethods 属性：
    引导方法：LambdaMetafactory.metafactory(...)
    静态参数：函数式接口方法签名、实际实现方法句柄、目标签名

执行流程：
  首次执行 invokedynamic → 调 metafactory 生成 CallSite
  后续执行 → 直接调用 CallSite.target（已生成的方法句柄）

二、`LambdaMetafactory.metafactory()` 引导方法

java

// java.lang.invoke.LambdaMetafactory
public static CallSite metafactory(MethodHandles.Lookup caller,
                                   String invokedName,
                                   MethodType invokedType,
                                   MethodType samMethodType,      // 函数式接口方法类型
                                   MethodHandle implMethod,       // 实际实现方法句柄
                                   MethodType instantiatedMethodType)
        throws Throwable {
    // 内部委托
    return InnerClassLambdaMetafactory.metafactory(caller, invokedName,
        invokedType, samMethodType, implMethod, instantiatedMethodType,
        false, EMPTY_CLASS_ARRAY, EMPTY_MT_ARRAY);
}

// InnerClassLambdaMetafactory
public static CallSite metafactory(...) throws Throwable {
    return new InnerClassLambdaMetafactory(caller, invokedName, invokedType,
        samMethodType, implMethod, instantiatedMethodType,
        isSerializable, altInterfaces, altMethods)
        .buildCallSite();        // 核心：构建调用点
}

metafactory 参数：
  caller          ：调用者上下文（权限来源）
  invokedName     ：函数式接口的抽象方法名（如 run/apply）
  invokedType     ：调用点签名
  samMethodType   ：函数式接口方法类型（SAM 类型）
  implMethod      ：实际执行的方法句柄（如 lambda$main$0）
  instantiatedMethodType：实例化后的方法类型

三、`buildCallSite()` 与 `spinInnerClass()` 的类生成

java

// InnerClassLambdaMetafactory.buildCallSite
CallSite buildCallSite() throws Throwable {
    // ① 检查权限：调用者能否访问实现方法
    checkAdapter();
    ...
    // ② 生成实现类（ASM 动态生成字节码）
    Class<?> innerClass = spinInnerClass();
    ...
    // ③ 实例化实现类 → 绑定方法句柄
    MethodHandle mh = MethodHandles.constant(innerClass, instance);
    ...
    return new ConstantCallSite(mh);   // 返回调用点（后续调用直接命中）
}

private Class<?> spinInnerClass() throws Throwable {
    // ④ 用 ASM 生成类字节码
    String[] interfaces = ...;           // 实现函数式接口
    ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
    // 生成：class LambdaTest$$Lambda$1 implements Runnable { ... }
    // 内含：run() → LambdaTest.lambda$main$0() 调用（invokedynamic 实现方法）
    return UNSAFE.defineAnonymousClass(targetClass, cw.toByteArray(), null);
    // 用 defineAnonymousClass 定义（隐藏类，与宿主类同加载器）
}

ASM 生成过程：
  动态生成 LambdaTest$$Lambda$1 类（隐藏类/匿名类）
  实现函数式接口（Runnable → 实现 run()）
  方法体内调用实现方法（lambda$main$0 → 静态/实例方法）
  用 defineAnonymousClass 定义 → 加载到 JVM

优点：
  运行期生成 → 编译产物无额外类文件
  实例可共享缓存（同一 lambda 表达式复用）
  JIT 可内联优化（方法句柄形式）

四、Lambda 的序列化 `SerializedLambda`

java

// 函数式接口声明可序列化
@FunctionalInterface
public interface SerializableRunnable extends Runnable, Serializable { }

// 实现类生成时标记可序列化 → 支持 SerializedLambda 机制

java

// java.lang.invoke.SerializedLambda
public final class SerializedLambda implements Serializable {
    private final Class<?> capturingClass;   // 捕获类
    private final String functionalInterfaceClass;  // 函数式接口
    private final String functionalInterfaceMethodName;
    private final String implClass;          // 实现类
    private final String implMethodName;     // 实现方法名
    private final MethodHandleKind implMethodKind;  // 实现方法种类
    ...
}

Lambda 序列化机制：
  实现类中有 writeReplace() → 序列化时替换为 SerializedLambda
  序列化的是"描述"（implClass + implMethodName + 捕获参数）
  反序列化时 readResolve() → 重新构建 lambda（MethodHandle + 参数）
  要求：实现方法必须是 static 或带捕获的可序列化字段

  writeReplace 示例（生成的实现类）：
    private Object writeReplace() {
        return new SerializedLambda(capturingClass, ..., implMethodName, ...);
    }

五、`MethodHandle` 的类型匹配

5.1 `invokeExact()` 严格类型

java

// java.lang.invoke.MethodHandle
public final native Object invokeExact(Object... args) throws Throwable;

MethodHandle mh = MethodHandles.lookup().findStatic(Math.class, "max", 
    MethodType.methodType(int.class, int.class, int.class));
// invokeExact 必须精确匹配 (int, int) → int
int r = (int) mh.invokeExact(1, 2);   // ✅ 精确匹配
// mh.invokeExact(1L, 2);            // ❌ long 不匹配 int → 编译/运行错误

invokeExact 语义：
  参数与返回类型必须与 MethodType 完全一致
  无自动转型（不装箱、不宽化、不转型）
  性能最好（JIT 可完全内联）

5.2 `invoke()` 宽松类型

java

public final Object invoke(Object... args) throws Throwable {
    // 内部：asType 转换 + invokeExact
    return asType(type().generic()).invokeExact(args);
    // 实际实现：asType() 生成适配器 → invokeExact
}

// 宽松语义：允许
//   基本类型 ↔ 包装类型（装箱/拆箱）
//   类型扩展（int → long）
//   子类 → 父类 / 接口
//   Object 泛化

java

// invoke 允许自动转型
int r1 = (int) mh.invoke(1, 2);          // 精确同 invokeExact
int r2 = (int) mh.invoke(1L, 2);         // long → int 适配（拆箱/转换）
long r3 = (long) mh.invoke(1, 2);        // int 结果 → long 宽化

invoke vs invokeExact：
  invokeExact：类型精确，零开销，适合确定场景
  invoke：asType 适配 + invokeExact，灵活但有适配开销

六、`MethodHandles.Lookup` 权限检查

java

// java.lang.invoke.MethodHandles.Lookup
public class Lookup {
    private final Class<?> lookupClass;    // 查找上下文类
    private final int allowedModes;        // 允许的访问模式位掩码

    static final int PUBLIC = 0x01;
    static final int PRIVATE = 0x02;
    static final int PROTECTED = 0x04;
    static final int PACKAGE = 0x08;
    static final int UNCONDITIONAL = 0x10;

    // 查找方法受 allowedModes 限制：
    // findStatic/findVirtual/findSpecial/findGetter...
    // 权限不足 → IllegalAccessException
}

Lookup 权限语义：
  Lookup 在编译期绑定到调用者类（caller class）
  allowedModes 决定能访问的成员范围：
    PUBLIC：public 成员
    PRIVATE：私有成员（同类内）
    PACKAGE：包内成员
    PROTECTED：受保护成员（子类内）
  权限提升限制：模块系统（模块化）进一步约束跨模块访问
  安全：恶意代码无法通过 Lookup 访问无权访问的成员

java

// 用法示例
MethodHandles.Lookup lookup = MethodHandles.lookup();   // 当前类上下文
MethodHandle mh = lookup.findStatic(MyClass.class, "myStatic",
    MethodType.methodType(void.class));

七、`LambdaForm` 的解释执行与编译

java

// java.lang.invoke.LambdaForm
final class LambdaForm {
    final MethodType vmentry;       // 虚拟机入口类型
    final int flags;
    final NamedFunction[] names;    // 指令序列（方法调用节点）
    final Object[] constants;       // 常量池
    final Class<?> result;          // 返回类型

    // 两种执行方式：
    // 解释执行：invokeBasic 逐个执行 names（字节码解释）
    // 编译执行：生成字节码（LambdaForm 编译为方法）
}

LambdaForm 是什么：
  方法句柄的内部"字节码级"表示（AST 形式的调用图）
  每个 MethodHandle 有对应的 LambdaForm

执行路径：
  invokeBasic()  → 解释执行 LambdaForm（逐指令）
  热点 LambdaForm → 编译为字节码/JIT 原生代码（性能等同直接调用）

BoundMethodHandle：
  方法句柄 + 绑定的参数（常量/接收者）
  LambdaForm 里引用这些绑定值
  链式组合：methodHandle.compose(另一个 mh)

LambdaForm 与 JIT：
  首次调用 → 解释执行（慢）
  热点 → 编译成字节码类 → 再被 JIT 优化
  → MethodHandle 最终性能接近直接方法调用
  （这也是 Lambda 不输匿名内部类的原因）

八、实现要点

Lambda 核心：
  invokedynamic：运行期动态解析调用点（BootstrapMethods 属性）
  LambdaMetafactory：引导方法 → InnerClassLambdaMetafactory
  spinInnerClass：ASM 生成实现类（隐藏类，defineAnonymousClass）
  SerializedLambda：序列化描述（implClass/implMethodName + 捕获参数）
  MethodHandle.invokeExact：精确类型，零适配开销
  MethodHandle.invoke：asType 宽松适配（装箱/宽化）
  MethodHandles.Lookup：allowedModes 权限位（PUBLIC/PRIVATE...）
  LambdaForm：方法句柄内部表示（解释 → 编译 → JIT）

常见陷阱：
  invokeExact 类型不匹配 → 异常（需精确匹配）
  序列化 Lambda 需接口继承 Serializable 且实现方法可序列化
  Lookup 权限不足 → IllegalAccessException（模块系统更严）
  Lambda 捕获可变局部变量 → 编译错误（需 final/effectively final）
  大循环内创建 Lambda → 单例缓存（同一 lambda 表达式复用实例）

Lambda 表达式 / InvokeDynamic / LambdaMetafactory 源码精读 ​

概述 ​

一、invokedynamic 指令的调用点 ​

二、LambdaMetafactory.metafactory() 引导方法 ​

三、buildCallSite() 与 spinInnerClass() 的类生成 ​

四、Lambda 的序列化 SerializedLambda ​

五、MethodHandle 的类型匹配 ​

5.1 invokeExact() 严格类型 ​

5.2 invoke() 宽松类型 ​

六、MethodHandles.Lookup 权限检查 ​

七、LambdaForm 的解释执行与编译 ​

八、实现要点 ​

Lambda 表达式 / `InvokeDynamic` / `LambdaMetafactory` 源码精读

概述

一、`invokedynamic` 指令的调用点

二、`LambdaMetafactory.metafactory()` 引导方法

三、`buildCallSite()` 与 `spinInnerClass()` 的类生成

四、Lambda 的序列化 `SerializedLambda`

五、`MethodHandle` 的类型匹配

5.1 `invokeExact()` 严格类型

5.2 `invoke()` 宽松类型

六、`MethodHandles.Lookup` 权限检查

七、`LambdaForm` 的解释执行与编译

八、实现要点