Szybsze alternatywy dla odbicia Javy [zamknięty]

Alternatywą dla Reflection jest dynamiczne generowanie pliku klasy. Ta wygenerowana klasa powinna wykonać żądaną akcję, np. wywołuje metodę odkrytą w czasie wykonywania i implementuje interface znaną w czasie kompilacji, tak aby możliwe było wywołanie Wygenerowanej metody w sposób nieodblaskowy za pomocą tego interfejsu. Jest jeden haczyk: jeśli dotyczy, odbicie robi tę samą sztuczkę wewnętrznie. Nie działa to w szczególnych przypadkach, np. podczas wywoływania metody private, ponieważ nie można wygenerować akt prawny. Tak więc w implementacji Reflection istnieją różne typy obsługi wywołań, wykorzystujące wygenerowany kod lub kod natywny. Nie pokonasz tego.

Od Java 7 {[24] } istnieje alternatywa dla obu, MethodHandle. Dużą zaletą jest to, że w przeciwieństwie do pozostałych dwóch, działa nawet w środowiskach o ograniczonym dostępie. Kontrola dostępu dla MethodHandle jest wykonywana podczas jej pozyskiwania, ale nie podczas jej wywoływania. Posiada tzw. "sygnaturę polimorficzną", co oznacza, że można ją wywoływać dowolnymi typami argumentów bez auto-boksu ani tworzenia tablicy. Oczywiście błędne typy argumentów stworzy odpowiednią RuntimeException.

(Aktualizacja ) Z Java 8 istnieje możliwość użycia zaplecza wyrażenia lambda i funkcji języka referencyjnego metody w czasie wykonywania. Ten backend robi dokładnie to, co opisano na początku, generując klasę dynamicznie implementującą interface Twój kod może wywołać bezpośrednio, gdy jest znany w czasie kompilacji. Dokładna mechanika jest specyficzna dla implementacji, stąd niezdefiniowana, ale można założyć, że implementacja postaramy się, aby zaproszenie tak szybko, jak to możliwe. Obecna implementacja JRE firmy Oracle robi to doskonale. Nie tylko, że pozwala to zaoszczędzić od ciężaru generowania takiej klasy accessora, ale jest również w stanie zrobić to, czego nigdy nie mogłeś zrobić-wywołać nawet private metody za pomocą wygenerowanego kodu. Zaktualizowałem przykład, aby uwzględnić to rozwiązanie. Ten przykład używa standardu interface, który już istnieje i ma pożądany podpis metody. If no such matching interface istnieje, musisz stworzyć własny interfejs funkcjonalny accessora z metodą z odpowiednim podpisem. Ale, oczywiście, teraz przykładowy kod wymaga Java 8 do uruchomienia.

import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.lang.reflect.Method;
import java.util.function.IntBinaryOperator;

public class TestMethodPerf
{
  private static final int ITERATIONS = 50_000_000;
  private static final int WARM_UP = 10;

  public static void main(String... args) throws Throwable
  {
 // hold result to prevent too much optimizations
    final int[] dummy=new int[4];

    Method reflected=TestMethodPerf.class
      .getDeclaredMethod("myMethod", int.class, int.class);
    final MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodHandle mh=lookup.unreflect(reflected);
    IntBinaryOperator lambda=(IntBinaryOperator)LambdaMetafactory.metafactory(
      lookup, "applyAsInt", MethodType.methodType(IntBinaryOperator.class),
      mh.type(), mh, mh.type()).getTarget().invokeExact();

    for(int i=0; i<WARM_UP; i++)
    {
      dummy[0]+=testDirect(dummy[0]);
      dummy[1]+=testLambda(dummy[1], lambda);
      dummy[2]+=testMH(dummy[1], mh);
      dummy[3]+=testReflection(dummy[2], reflected);
    }
    long t0=System.nanoTime();
    dummy[0]+=testDirect(dummy[0]);
    long t1=System.nanoTime();
    dummy[1]+=testLambda(dummy[1], lambda);
    long t2=System.nanoTime();
    dummy[2]+=testMH(dummy[1], mh);
    long t3=System.nanoTime();
    dummy[3]+=testReflection(dummy[2], reflected);
    long t4=System.nanoTime();
    System.out.printf("direct: %.2fs, lambda: %.2fs, mh: %.2fs, reflection: %.2fs%n",
      (t1-t0)*1e-9, (t2-t1)*1e-9, (t3-t2)*1e-9, (t4-t3)*1e-9);

    // do something with the results
    if(dummy[0]!=dummy[1] || dummy[0]!=dummy[2] || dummy[0]!=dummy[3])
      throw new AssertionError();
  }

  private static int testMH(int v, MethodHandle mh) throws Throwable
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=(int)mh.invokeExact(1000, v);
    return v;
  }

  private static int testReflection(int v, Method mh) throws Throwable
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=(int)mh.invoke(null, 1000, v);
    return v;
  }

  private static int testDirect(int v)
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=myMethod(1000, v);
    return v;
  }

  private static int testLambda(int v, IntBinaryOperator accessor)
  {
    for(int i=0; i<ITERATIONS; i++)
      v+=accessor.applyAsInt(1000, v);
    return v;
  }

  private static int myMethod(int a, int b)
  {
    return a<b? a: b;
  }
}

Stary program wydrukowany w mojej konfiguracji Java 7: direct: 0,03s, mh: 0,32s, reflection: 1,05s, który sugerował, że MethodHandle jest dobrą alternatywą. Teraz zaktualizowany program działający pod Javą 8 na tym samym komputerze wydrukował direct: 0,02s, lambda: 0,02s, mh: 0,35s, reflection: 0,40s, co wyraźnie pokazuje, że wydajność odbicia została poprawiona do pewnego stopnia to może sprawić, że radzenie sobie z MethodHandle będzie zbędne, chyba że użyjesz go do triku lambda, który wyraźnie przewyższa wszystkie odblaskowe alternatywy, co nie jest zaskoczeniem, ponieważ jest to tylko bezpośrednie połączenie (no, prawie: jeden poziom indrection). Zauważ, że stworzyłem metodę docelową private, aby zademonstrować możliwość efektywnego wywoływania metod even private.

Jak zawsze, muszę zwrócić uwagę na prostotę tego benchmarka i na to, jak sztuczny jest ten benchmark. Ale myślę, że tendencja jest wyraźnie widoczne i co ważniejsze, wyniki są przekonująco wyjaśnione.