将 BiConsumer 创建为 Field setter 而不进行反射

Question

我试图在我的一个脚本中获得最大性能，而不进行重大重构。

我发现了使用反射从 Field 创建 BiConsumer 的方法。

return (c, v) -> {
    try {
        field.set(c, v);
    } catch (final Throwable e) {
        throw new RuntimeException("Could not set field: " + field, e);
    }
};

反射以速度慢着称。所以我虽然可以使用方法句柄。

Lookup lookup = MethodHandles.lookup();
MethodHandle mh = lookup.unreflectSetter(field);
return (c, v) -> {
    try {
        mh.invoke(c, v);
    } catch (final Throwable e) {
        throw new RuntimeException("Could not set field: " + field, e);
    }
};

这已经快了一点点。然而 BiConsumer 是一个 FunctionalInterface 可以以某种方式生成。

public static <C, V> BiConsumer<C, V> createSetter(final MethodHandles.Lookup lookup,
        final Field field) throws Exception {
    final MethodHandle setter = lookup.unreflectSetter(field);
    final CallSite site = LambdaMetafactory.metafactory(lookup,
            "accept",
            MethodType.methodType(BiConsumer.class),
            MethodType.methodType(void.class, Object.class, Object.class), // signature of method BiConsumer.accept after type erasure
            setter,
            setter.type()); // actual signature of setter
    return (BiConsumer<C, V>) site.getTarget().invokeExact();
}

但是我得到了一个我不太理解的异常

Exception in thread "main" java.lang.invoke.LambdaConversionException: Unsupported MethodHandle kind: putField org.sample.dto.TestDTO.name:(String)void
    at java.lang.invoke.AbstractValidatingLambdaMetafactory.validateMetafactoryArgs(AbstractValidatingLambdaMetafactory.java:182)
    at java.lang.invoke.LambdaMetafactory.metafactory(LambdaMetafactory.java:303)
    at org.sample.bench.MyBenchmark.createSetter(MyBenchmark.java:120)
    at org.sample.bench.MyBenchmark.main(MyBenchmark.java:114)

我必须以哪种方式正确生成 setter 以提高性能。（实际上没有添加 setter 方法）

Answer 1

功能上 MethodHandleProxies::asInterfaceInstance 似乎很合适。不过不确定方法句柄代理对性能的影响。

Answer 2

您可以使用调用程序 MethodHandle:

public static <C, V> BiConsumer<C, V> createSetter(
                     MethodHandles.Lookup lookup, Field field) throws Throwable {
    final MethodHandle setter = lookup.unreflectSetter(field);
    MethodType type = setter.type();
    if(field.getType().isPrimitive())
        type = type.wrap().changeReturnType(void.class);
    final CallSite site = LambdaMetafactory.metafactory(lookup,
        "accept", MethodType.methodType(BiConsumer.class, MethodHandle.class),
        type.erase(), MethodHandles.exactInvoker(setter.type()), type);
    return (BiConsumer<C, V>)site.getTarget().invokeExact(setter);
}

由于 LambdaMetafactory 不允许为字段方法句柄生成函数实例，上面的代码为方法句柄创建一个函数实例，相当于在字段访问器方法上调用 invokeExact手柄。

在最坏的情况下，生成的代码与执行手动调用方法句柄的 invoke 方法的 lambda 表达式生成的代码没有区别，因此性能与

public static <C, V> BiConsumer<C, V> createSetterU(
                     MethodHandles.Lookup lookup, Field field) throws Throwable {
    MethodHandle setter = lookup.unreflectSetter(field);
    return (c, v) -> {
        try {
            setter.invoke(c, v);
        } catch (final Throwable e) {
            throw new RuntimeException("Could not set field: " + field, e);
        }
    };
}

但是，在某些情况下，调用程序方法句柄的效率可能会稍高一些。首先，它使用等效于 invokeExact 而不是 invoke 的选项，由于类型擦除，通用代码无法使用。其次，当代码图中不涉及用户代码时，可能会有一些内部调整。

将 BiConsumer 创建为 Field setter 而不进行反射

Create BiConsumer as Field setter without reflection

java

reflection

methodhandle