LambdaMetafactory创建性能远低于Lambda，求问题排查与优化方案

我希望用LambdaMetafactory创建反射场景下的构造器、Getter和Setter方法，生成的Function调用性能和直接调用一致这点符合需求，但测试手动实现和直接Lambda的生成性能时结果差距极大：

@Benchmark
public void testLambdaGeneration(Blackhole bh) {
    Function<Object, Object> function = a -> {
        if(a instanceof Alpha alpha) {
            return alpha.primitiveInt();
        }else {
            throw new RuntimeException();
        }
    };
    bh.consume(function);
}

@Benchmark
public void testManualGeneration(Blackhole bh) {
    try{
        MethodHandle mh = MethodHandles.lookup().findVirtual(Alpha.class, "primitiveInt", MethodType.methodType(int.class));
        MethodType type = mh.type();
        type = type.changeReturnType(Integer.class);
        CallSite callSite = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                "apply",
                MethodType.methodType(Function.class),
                type.erase(), mh, type);
        Function<Object, Object> f = (Function<Object, Object>) callSite.getTarget().invokeExact();
        bh.consume(f);
    }catch (Throwable e) {
        throw new RuntimeException("Unreached");
    }
}

测试结果：

LambdaTest.testLambdaGeneration  avgt   50      0.574 ±     0.015  ns/op
LambdaTest.testManualGeneration  avgt   50  29424.815 ± 20402.801  ns/op

问题根源 #

• 直接Lambda的预优化：编译器在编译阶段就把Lambda转成了调用LambdaMetafactory的字节码，JVM会在类加载时提前完成Lambda类的生成、链接，你的基准测试里testLambdaGeneration每次执行只是复用已生成好的Lambda实例，几乎没额外开销。
• 手动实现的重复生成：testManualGeneration每次迭代都要重新执行方法句柄查找、LambdaMetafactory调用、实例化流程，每次都要生成新的Lambda类、处理类加载等heavyweight操作，性能自然拉胯。

优化方案 #

1. 缓存生成的Function实例 #

把Lambda生成逻辑移到基准测试的初始化阶段，只生成一次，测试时直接复用：

private Function<Object, Object> cachedFunction;

@Setup(Level.Trial)
public void setup() throws Throwable {
    MethodHandle mh = MethodHandles.lookup().findVirtual(Alpha.class, "primitiveInt", MethodType.methodType(int.class));
    MethodType type = mh.type().changeReturnType(Integer.class);
    CallSite callSite = LambdaMetafactory.metafactory(
            MethodHandles.lookup(),
            "apply",
            MethodType.methodType(Function.class),
            type.erase(),
            mh,
            type
    );
    cachedFunction = (Function<Object, Object>) callSite.getTarget().invokeExact();
}

@Benchmark
public void testManualGenerationCached(Blackhole bh) {
    bh.consume(cachedFunction);
}

修改后手动实现的性能会和直接Lambda基本一致，因为避免了重复生成的开销。

2. 缓存MethodHandle实例 #

如果要生成不同方法的Lambda，可以提前缓存MethodHandle，避免每次都反射查找方法，进一步降低损耗。

3. 对齐类型处理逻辑 #

直接Lambda编译时会自动处理类型适配和装箱，手动实现时确保LambdaMetafactory的参数和编译器生成的一致，比如原Lambda里的类型判断逻辑，手动实现时可以通过方法句柄的类型转换对齐，避免额外性能损耗。

补充说明 #

Lambda表达式确实基于LambdaMetafactory实现，但编译器和JVM做了预生成、缓存Lambda类、复用实例等大量优化。手动调用时如果不做缓存，每次走完整生成流程，性能差距必然极大。只要把生成逻辑移到初始化阶段只执行一次，两者性能就能对齐。

内容的提问来源于stack exchange，提问作者benrush