Java Lambda 与匿名类之间的执行时间差很大

closures performance lambda java java-8

2022-09-02 09:49:58

我对针对同一匿名类创建java8 lambda实例的性能感到好奇（在win32 java build 1.8.0-ea-b106上执行测量）。我创建了非常简单的示例，并测量了java在创建lambda表达式时是否建议对运算符进行一些优化：new

static final int MEASURES = 1000000;
static interface ICallback{
    void payload(int[] a);
}
/**
* force creation of anonymous class many times
*/
static void measureAnonymousClass(){
    final int arr[] = {0};
    for(int i = 0; i < MEASURES; ++i){
        ICallback clb = new ICallback() {
            @Override
            public void payload(int[] a) {
                a[0]++;
            }
        };
        clb.payload(arr);
    }
}
/**
* force creation of lambda many times 
*/
static void measureLambda(){ 
    final int arr[] = {0};
    for(int i = 0; i < MEASURES; ++i){
        ICallback clb = (a2) -> {
            a2[0]++;
        };
        clb.payload(arr);
    }
}

（完整的代码可以在那里采取：http://codepad.org/Iw0mkXhD）结果相当可预测 - lambda 获胜 2 次。

但是，进行闭包的微小转变表明lambda的时机非常糟糕。匿名班级获胜10次！所以现在匿名类看起来像这样：

ICallback clb = new ICallback() {
        @Override
        public void payload() {
            arr[0]++;
        }
    };

lambda的作用如下：

ICallback clb = () -> {
            arr[0]++;
        };

（完整的代码可以在那里采取：http://codepad.org/XYd9Umty）谁能解释一下为什么在处理闭合方面存在如此大（坏）的差异？

答案 1

更新

一些评论想知道我在底部的基准测试是否有缺陷 - 在引入了很多随机性（以防止JIT优化太多东西）之后，我仍然得到类似的结果，所以我倾向于认为这是可以的。

与此同时，我遇到了 lambda 实现团队的演示。第 16 页显示了一些性能数据：内部类和闭包具有相似的性能/非捕获 lambda 的速度提高了 5 倍。

@StuartMarks发布了Sergey Kuksenko关于lambda性能的JVMLS 2013演讲。最重要的是，在JIT编译后，lambda和匿名类在当前的Hostpot JVM实现上执行类似。

您的基准

我也运行了你的测试，正如你发布的那样。问题在于，第一种方法的运行时间短短为 20 毫秒，第二种方法的运行时间为 2 毫秒。虽然这是10：1的比例，但它绝不具有代表性，因为测量时间太短了。

然后，我修改了您的测试，以允许更多的JIT预热，并且我得到了与jmh类似的结果（即匿名类和lambda之间没有区别）。

public class Main {

    static interface ICallback {
        void payload();
    }
    static void measureAnonymousClass() {
        final int arr[] = {0};
        ICallback clb = new ICallback() {
            @Override
            public void payload() {
                arr[0]++;
            }
        };
        clb.payload();
    }
    static void measureLambda() {
        final int arr[] = {0};
        ICallback clb = () -> {
            arr[0]++;
        };
        clb.payload();
    }
    static void runTimed(String message, Runnable act) {
        long start = System.nanoTime();
        for (int i = 0; i < 10_000_000; i++) {
            act.run();
        }
        long end = System.nanoTime();
        System.out.println(message + ":" + (end - start));
    }
    public static void main(String[] args) {
        runTimed("as lambdas", Main::measureLambda);
        runTimed("anonymous class", Main::measureAnonymousClass);
        runTimed("as lambdas", Main::measureLambda);
        runTimed("anonymous class", Main::measureAnonymousClass);
        runTimed("as lambdas", Main::measureLambda);
        runTimed("anonymous class", Main::measureAnonymousClass);
        runTimed("as lambdas", Main::measureLambda);
        runTimed("anonymous class", Main::measureAnonymousClass);
    }
}

对于这两种方法，最后一次运行大约需要 28 秒。

摩根大通微基准测试

我用jmh运行了相同的测试，底线是这四种方法花费的时间与等效方法一样多：

void baseline() {
    arr[0]++;
}

换句话说，JIT 将匿名类和 lambda 内联在一起，并且它们花费的时间完全相同。

结果摘要：

Benchmark                Mean    Mean error    Units
empty_method             1.104        0.043  nsec/op
baseline                 2.105        0.038  nsec/op
anonymousWithArgs        2.107        0.028  nsec/op
anonymousWithoutArgs     2.120        0.044  nsec/op
lambdaWithArgs           2.116        0.027  nsec/op
lambdaWithoutArgs        2.103        0.017  nsec/op

答案 2