Quand les références de méthodes de mise en cache dans Java 8 offrent-elles des avantages en termes de performances ?

La préservation des références de méthodes est-elle bénéfique dans Java 8 ?

Considérez l'extrait de code suivant :

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

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

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

Si la fonction hotFunction est appelée à plusieurs reprises, la mise en cache this::func peut être bénéfique.

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

Les machines virtuelles sont généralement créer des objets anonymes pour les références de méthode, donc la mise en cache de la référence crée l'objet une fois, tandis que la version non mise en cache le crée à chaque fois que hotFunction est invoquée.

Cependant, la distinction réside dans la fréquence d'exécution du même site d'appel et en utilisant une référence de méthode à la même méthode à partir de différents sites d'appel.

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

Le même site d'appel produit un lambda sans état et la JVM imprime "partagé."

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

Dans ce scénario, le même site d'appel produit un lambda avec une référence à une instance d'exécution, et la JVM imprime "non partagé" et "classe partagée".

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

Deux sites d'appel distincts produisent la même référence de méthode, mais la JVM affiche "non partagé" et "non partagé". class."

La JVM mémorise et réutilise les instances de site d'appel créées lors du premier appel. Pour les lambdas sans état et les sites d'appel uniques, il produit un objet constant. La JVM est autorisée à partager des références de méthode entre les sites d'appels, mais ce n'est pas le cas dans l'implémentation actuelle.

La mise en cache peut être bénéfique dans les cas suivants :

• De nombreux sites d'appels distincts font référence à la même méthode.
• Le lambda est instancié dans une initialisation constructeur/classe et utilisé par plusieurs threads simultanément.
• Le premier appel a réduit les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!