MethodHandle性能

Question

我编写了一个测试java.lang.Invoke.MethodHandle、java.lang.Reflect.Method和方法直接调用的性能的小基准测试。

我读到methodhandle.invoke()的性能几乎与直接调用相同。但我的测试结果显示了另一种情况:methodhandle调用比反射慢三倍。我的问题是什么？这可能是一些JIT优化的结果吗？

public class Main {
    public static final int COUNT = 100000000;
    static TestInstance test = new TestInstance();

    static void testInvokeDynamic() throws NoSuchMethodException, IllegalAccessException {
        int [] ar = new int[COUNT];

        MethodHandles.Lookup lookup = MethodHandles.lookup();
        MethodType mt = MethodType.methodType(int.class);

        MethodHandle handle = lookup.findStatic(TestInstance.class, "publicStaticMethod", mt) ;

        try {
            long start = System.currentTimeMillis();

            for (int i=0; i<COUNT; i++) {
                ar[i] = (int)handle.invokeExact();
            }

            long stop = System.currentTimeMillis();

            System.out.println(ar);

            System.out.println("InvokeDynamic time: " + (stop - start));
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    static void testDirect() {
        int [] ar = new int[COUNT];

        try {
            long start = System.currentTimeMillis();

            for (int i=0; i<COUNT; i++) {
                ar[i] = TestInstance.publicStaticMethod();
            }

            long stop = System.currentTimeMillis();

            System.out.println(ar);

            System.out.println("Direct call time: " + (stop - start));
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    static void testReflection() throws NoSuchMethodException {
        int [] ar = new int[COUNT];

        Method method = test.getClass().getMethod("publicStaticMethod");

        try {
            long start = System.currentTimeMillis();

            for (int i=0; i<COUNT; i++) {
                ar[i] = (int)method.invoke(test);
            }

            long stop = System.currentTimeMillis();

            System.out.println(ar);

            System.out.println("Reflection time: " + (stop - start));
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    static void testReflectionAccessible() throws NoSuchMethodException {
        int [] ar = new int[COUNT];

        Method method = test.getClass().getMethod("publicStaticMethod");
        method.setAccessible(true);

        try {
            long start = System.currentTimeMillis();

            for (int i=0; i<COUNT; i++) {
                ar[i] = (int)method.invoke(test);
            }

            long stop = System.currentTimeMillis();

            System.out.println(ar);

            System.out.println("Reflection accessible time: " + (stop - start));
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }

    public static void main(String ... args) throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, InterruptedException {
        Thread.sleep(5000);

        Main.testDirect();
        Main.testInvokeDynamic();
        Main.testReflection();
        Main.testReflectionAccessible();

        System.out.println("\n___\n");

        System.gc();
        System.gc();

        Main.testDirect();
        Main.testInvokeDynamic();
        Main.testReflection();
        Main.testReflectionAccessible();
    }
}

环境：java版本“1.7.0_11”java(TM)SE Runtime Environment（build 1.7.0_11-B21)java HotSpot(TM)64位服务器VM（build 23.6-B04，混合模式）OS-Windows 7 64

Answer 1

看起来@AlekseyShipilev在引用另一个查询时间接地回答了这个问题。在下面的链接中，我如何提高field.set（使用MethodHandles的perhap）的性能？

如果通读，您将看到显示类似发现的附加基准。直接调用很可能可以简单地通过JIT优化,根据上面的发现,不同之处在于：

• MethodHandle.Invoke=~195ns
• MethodHandle.InvokeExact=~10ns
• 直接呼叫=1.266 ns

所以--直接通话还是会更快，但MH非常快。对于大多数用例，这应该是足够的，并且肯定比旧的反射框架更快（顺便说一句--根据上面的发现，反射在java8 vm下也要快得多）

如果这种差异在您的系统中很明显，我会建议寻找不同的模式，而不是支持直接调用的直接反射。