When Does Caching Method References in Java 8 Offer Performance Benefits?

Is Preserving Method References Beneficial in Java 8?

Consider the following code snippet:

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

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

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

If the hotFunction is called repeatedly, caching this::func may be beneficial.

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

Virtual Machines typically create anonymous objects for method references, so caching the reference creates the object once, while the uncached version creates it each time hotFunction is invoked.

However, the distinction lies in the frequency of executing the same call-site and using a method-reference to the same method from different call-sites.

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

The same call-site produces a stateless lambda, and the JVM prints "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 this scenario, the same call-site produces a lambda with a reference to a Runtime instance, and the JVM prints "unshared" and "shared class."

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

Two distinct call-sites produce the same method reference, but the JVM prints "unshared" and "unshared class."

The JVM remembers and reuses call-site instances created on the first invocation. For stateless lambdas and single call-sites, it produces a constant object. The JVM is allowed to share method references between call-sites, but the current implementation does not.

Caching may be beneficial in the following cases:

• Numerous distinct call-sites refer to the same method.
• The lambda is instantiated in a constructor/class initialization and used by multiple threads concurrently.
• The first invocation has reduced performance.

The above is the detailed content of When Does Caching Method References in Java 8 Offer Performance Benefits?. For more information, please follow other related articles on the PHP Chinese website!