通过反射获取的方法的执行时间是否更长？

Limnic 发表于 Dev

林姆尼克

众所周知，可以使用方法来获取方法Reflection并通过返回的Method实例调用该方法。

我的问题是；一旦获取它，Reflection并且我Method一遍又一遍地调用，该方法的性能是否会比正常调用方法慢？

例如：

import java.lang.reflect.Method;

public class ReflectionTest {

    private static Method test;

    public ReflectionTest() throws Exception {
        test = this.getClass().getMethod("testMethod", null);
    }

    public void testMethod() {
        //execute code here
    }

    public static void main(String[] args) throws Exception {
        ReflectionTest rt = new ReflectionTest();
        for (int i = 0; i < 1000; i++) {
            rt.test.invoke(null, null);
        }

        for (int i = 0; i < 1000; i++) {
            rt.testMethod();
        }
    }
}

我之所以这么问是因为我正在创建一个事件系统，该事件系统在注册侦听器后会扫描注释。将这些方法放入映射中，然后在每次发生所需参数类型的事件时执行这些方法。我不知道这是否足以胜任例如游戏。

艾略特新鲜

使用无反射的方法大约要快一个数量级。我测试像

public static void main(String[] args) throws Exception {
    ReflectionTest rt = new ReflectionTest();
    // Warm up
    for (int i = 0; i < 100; i++) {
        test.invoke(rt, null);
    }
    for (int i = 0; i < 100; i++) {
        rt.testMethod();
    }

    long start = System.nanoTime();
    for (int i = 0; i < 10000; i++) {
        test.invoke(rt, null);
    }
    long end = Math.abs((start - System.nanoTime()) / 1000);
    start = System.nanoTime();
    for (int i = 0; i < 10000; i++) {
        rt.testMethod();
    }
    long end2 = Math.abs((start - System.nanoTime()) / 1000);
    System.out.printf("%d %d%n", end, end2);
}

我也搬到test了一个static领域，以便它可以编译并运行

private static Method test;
static {
    try {
        test = ReflectionTest.class.getMethod("testMethod");
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    } catch (SecurityException e) {
        e.printStackTrace();
    }
}

我得到一个相当一致的差异（或输出一致）