方法引用缓存在Java 8中是个好主意吗？

Question 1

考虑我有如下代码：

class Foo {

   Y func(X x) {...} 

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

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

}

假设hotFunction经常调用。那么建议缓存this::func如下：

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

据我对java方法引用的理解，使用方法引用时，虚拟机会创建一个匿名类的对象。因此，缓存引用只会创建一次该对象，而第一种方法是在每个函数调用上创建该对象。它是否正确？

应该缓存出现在代码中热门位置的方法引用，还是VM能够优化它，并使多余的缓存？是否有一般的最佳实践，还是这种高度VM实施特定于这种缓存是否有用？

Question 2

对于无状态Lambda或有状态Lambda ，必须区分频繁执行同一调用站点的情况，以及频繁使用对同一方法的方法引用（通过不同的调用站点）的情况。

看下面的例子：

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

在这里，相同的调用站点将执行两次，生成无状态的lambda，并且当前的实现将打印出来"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");
  }
}

在第二个示例中，同一调用站点被执行两次，生成一个包含对Runtime实例的引用的lambda，并且当前实现将打印出来，"unshared"但是"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");

相反，在最后一个示例中，是两个不同的调用站点，它们产生等效的方法引用，但从那时起1.8.0_05，将打印"unshared"和"unshared class"。

对于每个lambda表达式或方法引用，编译器将发出一条invokedynamic指令，该指令引用该类中JRE提供的引导方法LambdaMetafactory以及生成所需lambda实现类所需的静态参数。元工厂生成的内容将留给实际的JRE，但这是invokedynamic指令的指定行为，可以记住并重新使用CallSite在第一次调用时创建的实例。

当前的JRE为无状态的lambda生成一个ConstantCallSite包含aMethodHandle的常量对象（并且没有可想象的理由进行不同的处理）。并且对方法的方法引用static始终是无状态的。因此，对于无状态的lambda和单个调用站点，答案必须是：不缓存，JVM会这样做，如果不缓存，则必须有强烈的理由，您不应该进行抵消。

对于具有参数this::func的lambda ，并且是具有this实例引用的lambda，情况有所不同。允许JRE缓存它们，但这意味着Map在实际参数值和所得的lambda之间保持某种形式，这可能比再次创建该简单的结构化lambda实例要昂贵得多。当前的JRE不缓存具有状态的Lambda实例。

但这并不意味着每次都会创建lambda类。这仅意味着已解析的调用站点将像普通对象构造一样，实例化在第一次调用时生成的lambda类。

类似的情况适用于对由不同调用站点创建的相同目标方法的方法引用。允许JRE在它们之间共享一个Lambda实例，但是在当前版本中，它不允许共享，这很可能是因为不清楚缓存维护是否会奏效。在这里，即使生成的类也可能不同。

因此，像您的示例一样进行缓存可能会使您的程序执行不同的操作。但不一定更有效。缓存的对象并不总是比临时对象更有效。除非您真的测量了由lambda创建引起的性能影响，否则不应该添加任何缓存。

我认为，仅在某些特殊情况下缓存可能有用：

我们谈论的是涉及相同方法的许多不同呼叫站点
lambda是在构造函数/类初始化中创建的，因为稍后在使用站点上将
- 同时被多个线程调用
- 遭受第一次调用性能降低的困扰

Question 3

不幸的是，这是一个非常理想的情况，如果您想在将来某个时候将lambda作为侦听器传递，则希望将其删除。当传递另一个this :: method引用时，将需要缓存的引用，而不会将其视为删除中的同一对象，并且不会删除原始对象。例如：

public class Example
{
    public void main( String[] args )
    {
        new SingleChangeListenerFail().listenForASingleChange();
        SingleChangeListenerFail.observableValue.set( "Here be a change." );
        SingleChangeListenerFail.observableValue.set( "Here be another change that you probably don't want." );

        new SingleChangeListenerCorrect().listenForASingleChange();
        SingleChangeListenerCorrect.observableValue.set( "Here be a change." );
        SingleChangeListenerCorrect.observableValue.set( "Here be another change but you'll never know." );
    }

    static class SingleChangeListenerFail
    {
        static SimpleStringProperty observableValue = new SimpleStringProperty();

        public void listenForASingleChange()
        {
            observableValue.addListener(this::changed);
        }

        private<T> void changed( ObservableValue<? extends T> observable, T oldValue, T newValue )
        {
            System.out.println( "New Value: " + newValue );
            observableValue.removeListener(this::changed);
        }
    }

    static class SingleChangeListenerCorrect
    {
        static SimpleStringProperty observableValue = new SimpleStringProperty();
        ChangeListener<String> lambdaRef = this::changed;

        public void listenForASingleChange()
        {
            observableValue.addListener(lambdaRef);
        }

        private<T> void changed( ObservableValue<? extends T> observable, T oldValue, T newValue )
        {
            System.out.println( "New Value: " + newValue );
            observableValue.removeListener(lambdaRef);
        }
    }
}

在这种情况下不需要lambdaRef会很好。

Question 4

据我了解的语言规范，即使它改变了可观察的行为，它也允许这种优化。请参见JSL8§15.13.3节中的以下引号：

§15.13.3方法引用的运行时评估

在运行时，只要正常完成产生，对方法引用表达式的评估与对类实例创建表达式的评估相似。对对象的引用即可。[..]

[..]或者分配和初始化具有以下属性的类的新实例，或者引用具有以下属性的类的现有实例。

一个简单的测试表明，静态方法的方法引用（可以）为每个评估得出相同的引用。下面的程序打印三行，其中前两行相同：

public class Demo {
    public static void main(String... args) {
        foobar();
        foobar();
        System.out.println((Runnable) Demo::foobar);
    }
    public static void foobar() {
        System.out.println((Runnable) Demo::foobar);
    }
}

对于静态函数，我无法重现同样的效果。但是，我没有在语言规范中找到任何东西来抑制这种优化。

因此，只要没有性能分析来确定此手动优化的价值，我强烈建议您不要这样做。缓存会影响代码的可读性，目前尚不清楚它是否具有任何价值。过早的优化是万恶之源。