如何提高field.set（使用MethodHandles的perhap）的性能？

Question

我正在编写一些调用field.set和field.get几千次的代码。显然这是非常缓慢的，因为反射。

我想看看是否可以在Java7中使用methodhandle来提高性能。到目前为止，我有以下资料：

不是field.set(pojo,value)，而是：

private static final Map<Field, MethodHandle> setHandles = new HashMap<>();

MethodHandle mh = setHandles.get(field);
if (mh == null) {
    mh = lookup.unreflectSetter(field);
    setHandles.put(field, mh);
}
mh.invoke(pojo, value);

但是，这似乎并不比使用反射的field.set调用执行得更好。我是不是做错什么了？

我读到使用InvokeExact可能更快，但当我尝试使用它时，我得到了一个java.lang.Invoke.WrongMethodTypeException。

是否有人成功地优化了对field.set或field.get的重复调用？

Answer 1

2015-06-01:更新以反映@joec关于句柄是静态的另一种情况的评论。也更新到最新的JMH和重新运行的现代硬件。结论几乎保持不变。

请做适当的基准测试，这对JMH来说并不是那么难。一旦你这么做了，答案就变得显而易见了。它还可以展示invokeexact的正确使用（需要目标/源1.7才能编译和运行）：

@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(3)
@BenchmarkMode(Mode.AverageTime)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@State(Scope.Thread)
public class MHOpto {

    private int value = 42;

    private static final Field static_reflective;
    private static final MethodHandle static_unreflect;
    private static final MethodHandle static_mh;

    private static Field reflective;
    private static MethodHandle unreflect;
    private static MethodHandle mh;

    // We would normally use @Setup, but we need to initialize "static final" fields here...
    static {
        try {
            reflective = MHOpto.class.getDeclaredField("value");
            unreflect = MethodHandles.lookup().unreflectGetter(reflective);
            mh = MethodHandles.lookup().findGetter(MHOpto.class, "value", int.class);
            static_reflective = reflective;
            static_unreflect = unreflect;
            static_mh = mh;
        } catch (IllegalAccessException | NoSuchFieldException e) {
            throw new IllegalStateException(e);
        }
    }

    @Benchmark
    public int plain() {
        return value;
    }

    @Benchmark
    public int dynamic_reflect() throws InvocationTargetException, IllegalAccessException {
        return (int) reflective.get(this);
    }

    @Benchmark
    public int dynamic_unreflect_invoke() throws Throwable {
        return (int) unreflect.invoke(this);
    }

    @Benchmark
    public int dynamic_unreflect_invokeExact() throws Throwable {
        return (int) unreflect.invokeExact(this);
    }

    @Benchmark
    public int dynamic_mh_invoke() throws Throwable {
        return (int) mh.invoke(this);
    }

    @Benchmark
    public int dynamic_mh_invokeExact() throws Throwable {
        return (int) mh.invokeExact(this);
    }

    @Benchmark
    public int static_reflect() throws InvocationTargetException, IllegalAccessException {
        return (int) static_reflective.get(this);
    }

    @Benchmark
    public int static_unreflect_invoke() throws Throwable {
        return (int) static_unreflect.invoke(this);
    }

    @Benchmark
    public int static_unreflect_invokeExact() throws Throwable {
        return (int) static_unreflect.invokeExact(this);
    }

    @Benchmark
    public int static_mh_invoke() throws Throwable {
        return (int) static_mh.invoke(this);
    }

    @Benchmark
    public int static_mh_invokeExact() throws Throwable {
        return (int) static_mh.invokeExact(this);
    }

}

在1x4x2 i7-4790K、JDK 8U40、Linux x86_64上生成：

Benchmark                             Mode  Cnt  Score   Error  Units
MHOpto.dynamic_mh_invoke              avgt   25  4.393 ± 0.003  ns/op
MHOpto.dynamic_mh_invokeExact         avgt   25  4.394 ± 0.007  ns/op
MHOpto.dynamic_reflect                avgt   25  5.230 ± 0.020  ns/op
MHOpto.dynamic_unreflect_invoke       avgt   25  4.404 ± 0.023  ns/op
MHOpto.dynamic_unreflect_invokeExact  avgt   25  4.397 ± 0.014  ns/op
MHOpto.plain                          avgt   25  1.858 ± 0.002  ns/op
MHOpto.static_mh_invoke               avgt   25  1.862 ± 0.015  ns/op
MHOpto.static_mh_invokeExact          avgt   25  1.859 ± 0.002  ns/op
MHOpto.static_reflect                 avgt   25  4.274 ± 0.011  ns/op
MHOpto.static_unreflect_invoke        avgt   25  1.859 ± 0.002  ns/op
MHOpto.static_unreflect_invokeExact   avgt   25  1.858 ± 0.002  ns/op

...这表明在这种情况下，MH确实比反射快得多（这是因为针对私有字段的访问检查是在查找时进行的，而不是在调用时进行的）。dynamic_*情况模拟methodhandles和/或字段不是静态已知的情况，例如从map 或类似的东西中提取。相反， static_*情况是调用者静态已知的情况。

注意，在dynamic_*情况下，反射性能与MethodHandles相当，这是因为反射在JDK 8中进一步进行了大量优化（因为实际上，您不需要访问检查来读取您自己的字段），所以答案可能是“仅仅”切换到JDK 8；）

static_*情况甚至更快，因为methandles.invoke调用是积极内联的。这消除了MH情况下的部分类型检查。但是，在反射情况下，仍然存在快速检查，因此，它滞后。