Wann bieten Caching-Methodenreferenzen in Java 8 Leistungsvorteile?

Ist das Beibehalten von Methodenreferenzen in Java 8 von Vorteil?

Beachten Sie den folgenden Codeausschnitt:

class Foo {
   Y func(X x) {...} 

   void doSomethingWithAFunc(Function<X,Y> f){...}

   void hotFunction(){
        doSomethingWithAFunc(this::func);
   }
}

Wenn die hotFunction wiederholt aufgerufen wird, wird zwischengespeichert this::func kann von Vorteil sein.

class Foo {
     Function<X,Y> f = this::func;
     ...
     void hotFunction(){
        doSomethingWithAFunc(f);
     }
}

Virtuelle Maschinen normalerweise Erstellen Sie anonyme Objekte für Methodenreferenzen. Durch das Zwischenspeichern der Referenz wird das Objekt also einmal erstellt, während die nicht zwischengespeicherte Version es jedes Mal erstellt, wenn hotFunction aufgerufen wird.

Der Unterschied liegt jedoch in der Häufigkeit der Ausführung derselben Aufrufstelle und Verwenden einer Methodenreferenz auf dieselbe Methode von verschiedenen Aufrufseiten.

Runnable r1=null;
for(int i=0; i<2; i++) {
    Runnable r2=System::gc;
    if(r1==null) r1=r2;
    else System.out.println(r1==r2? "shared": "unshared");
}

Die gleiche Aufrufseite erzeugt ein zustandsloses Lambda und die JVM druckt „shared.“

Runnable r1=null;
for(int i=0; i<2; i++) {
  Runnable r2=Runtime.getRuntime()::gc;
  if(r1==null) r1=r2;
  else {
    System.out.println(r1==r2? "shared": "unshared");
    System.out.println(
        r1.getClass()==r2.getClass()? "shared class": "unshared class");
  }
}

In diesem Szenario erzeugt dieselbe Aufrufseite ein Lambda mit einem Verweis auf eine Runtime-Instanz, und die JVM gibt „unshared“ und „shared class“ aus.

Runnable r1=System::gc, r2=System::gc;
System.out.println(r1==r2? "shared": "unshared");
System.out.println(
    r1.getClass()==r2.getClass()? "shared class": "unshared class");

Zwei unterschiedliche Aufrufseiten erzeugen die gleiche Methodenreferenz, aber die JVM gibt „unshared“ und „unshared class“ aus.

Die JVM merkt sich die beim ersten Aufruf erstellten Call-Site-Instanzen und verwendet sie wieder. Für zustandslose Lambdas und einzelne Aufrufseiten wird ein konstantes Objekt erzeugt. Die JVM darf Methodenreferenzen zwischen Aufrufstellen teilen, die aktuelle Implementierung jedoch nicht.

Caching kann in den folgenden Fällen von Vorteil sein:

• Zahlreiche unterschiedliche Aufrufstellen verweisen auf die gleiche Methode.
• Das Lambda wird in einer Konstruktor-/Klasseninitialisierung instanziiert und von mehreren Threads verwendet gleichzeitig.
• Der erste Aufruf hat die Leistung verringert.

Das obige ist der detaillierte Inhalt vonWann bieten Caching-Methodenreferenzen in Java 8 Leistungsvorteile?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!