Czy wykonanie metody pobranej przez odbicie trwa dłużej?

Question

Jak wszyscy wiecie, możliwe jest pobranie metody z Reflection i wywołanie jej za pomocą zwróconej instancji Method.

Moje pytanie jest jednak; po pobraniu przez Reflection i raz wywołać Method będzie wydajność metody będzie wolniejsza niż normalny sposób wywoływania metody?

Na przykład:

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(); 
     } 
    } 
} 

Pytam tego powodu Robię układ zdarzeń, które w momencie rejestracji słuchacza skanuje adnotacji. Metody są umieszczane na mapie, a następnie wykonywane za każdym razem, gdy wystąpi zdarzenie o wymaganym typie parametru. Nie wiem, czy jest wystarczająco wydajna, na przykład w grze.

Answer 1

Korzystanie z metody bez refleksji jest o rząd wielkości szybsze. Testowałem go jak

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); 
} 

ja też przeniósł test do pola static więc to skompilować i uruchomić

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

mam dość spójną różnicę (lub wyjście spójne) z

4526 606 

Co oznacza, że ​​w przypadku wywołania inwokacji 10000 odbicie jest ~ 7 razy wolniejsze niż wywołanie bezpośrednie.

Answer 2

@Elliot Frisch's zapewnia jednoznaczne dowody, że używanie Method.invoke() jest wolniejsze.

Można się tego spodziewać, ponieważ wersja odblaskowa wymaga dodatkowej pracy; na przykład

• tworzenie i inicjalizacji z układu zawierającego varags,
• sprawdzenie długości tablicy, a
• odlewania argumentów w tablicy z Object do odpowiednich typów parametrów.

Jest możliwe, że JIT mógłby mógł zoptymalizować to w niektórych przypadkach ...

---

^{1 - OK ... niejednoznaczne. Benchmark jest wątpliwy, ponieważ nie zwraca należytej uwagi na ewentualne anomalie związane z rozgrzewaniem JVM.}