我知道对 Java 微基准测试做出判断非常令人担忧，但我看到了一些看起来很奇怪的东西，我想得到一些解释。
请注意，我没有使用 JMH为此的框架。我知道这一点，但我不想为此耗费太多时间。
我将提供完整的代码示例，但简而言之，当我测试这两种方法的性能时
private FooPrime[] testStreamToArray(ArrayList<Foo> fooList) {
return (FooPrime[]) fooList.stream().
map(it -> {
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).
toArray(FooPrime[]::new);
}
private FooPrime[] testStreamToArray2(ArrayList<Foo> fooList) {
return (FooPrime[]) fooList.stream().
map(it -> {
int stuff = it.getAlpha().length();
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).
toArray(FooPrime[]::new);
}
我发现非常令人惊讶的结果。在较大的代码示例中，我测量了四种不同的执行方式，前三种的性能非常接近。它们每次迭代都运行大约 50k ns。但是，第二个代码示例始终运行不到总数的一半。这是正确的。它并不慢，而是快了很多。
最后一次运行显示这样的数字:
manualcopy:54575 ns
toarray:53617 ns
streamtoarray:52990 ns
streamtoarray2:24217 ns
每次运行都有与这些相似的数字。
我现在将提供整个类和基类。请注意，我确实有一个“热身”过程，在开始计时之前我执行了数千次被测方法。另请注意，虽然这最后运行“testStreamToArray2”，但我也尝试将该 block 移至第一个测试，结果数字大致相同。注释掉的行是为了让我相信这些方法实际上在做一些事情(时间仍然与那些没有注释掉的行大致相同)。
package timings;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class ListToArrayOfPrimesTiming {
public static void main(String[] args) {
ListToArrayOfPrimesTiming tests = new ListToArrayOfPrimesTiming(args);
tests.go();
}
public ListToArrayOfPrimesTiming(String[] args) { }
private void go() {
final ArrayList<Foo> fooList = new ArrayList<>();
for (int ctr = 0; ctr < 1000; ++ ctr) {
fooList.add(new Foo().alpha("a" + ctr).beta("b" + ctr));
}
for (int ctr = 0; ctr < 20000; ++ ctr) {
testManualCopy(fooList);
testToArray(fooList);
testStreamToArray(fooList);
testStreamToArray2(fooList);
}
int iters = 100000;
// Set<Integer> lengths = new HashSet<>();
// Set<FooPrime> distinctFooPrimes = new HashSet<>();
// lengths.clear();
// distinctFooPrimes.clear();
new TimingContainer(iters, "manualcopy", new TimingTest() {
@Override
public void run() {
FooPrime[] fooPrimeArray = testManualCopy(fooList);
// lengths.add(fooPrimeArray.length);
// distinctFooPrimes.add(fooPrimeArray[0]);
}
}).run();
// System.out.println("lengths[" + lengths + "]");
// lengths.clear();
// System.out.println("distinctFooPrimes[" + distinctFooPrimes + "]");
// distinctFooPrimes.clear();
new TimingContainer(iters, "toarray", new TimingTest() {
@Override
public void run() {
FooPrime[] fooPrimeArray = testManualCopy(fooList);
// lengths.add(fooPrimeArray.length);
// distinctFooPrimes.add(fooPrimeArray[0]);
}
}).run();
// System.out.println("lengths[" + lengths + "]");
// lengths.clear();
// System.out.println("distinctFooPrimes[" + distinctFooPrimes + "]");
// distinctFooPrimes.clear();
new TimingContainer(iters, "streamtoarray", new TimingTest() {
@Override
public void run() {
FooPrime[] fooPrimeArray = testStreamToArray(fooList);
// lengths.add(fooPrimeArray.length);
// distinctFooPrimes.add(fooPrimeArray[0]);
}
}).run();
// System.out.println("lengths[" + lengths + "]");
// lengths.clear();
// System.out.println("distinctFooPrimes[" + distinctFooPrimes + "]");
// distinctFooPrimes.clear();
new TimingContainer(iters, "streamtoarray2", new TimingTest() {
@Override
public void run() {
FooPrime[] fooPrimeArray = testStreamToArray2(fooList);
// lengths.add(fooPrimeArray.length);
// distinctFooPrimes.add(fooPrimeArray[0]);
}
}).run();
// System.out.println("lengths[" + lengths + "]");
// lengths.clear();
// System.out.println("distinctFooPrimes[" + distinctFooPrimes + "]");
// distinctFooPrimes.clear();
}
private FooPrime[] testManualCopy(ArrayList<Foo> fooList) {
FooPrime[] fooPrimeArray = new FooPrime[fooList.size()];
int index = -1;
for (Foo foo: fooList) {
++ index;
fooPrimeArray[index] = new FooPrime().gamma(foo.getAlpha() + foo.getBeta());
}
return fooPrimeArray;
}
private FooPrime[] testToArray(ArrayList<Foo> fooList) {
List<FooPrime> fooPrimeList = new ArrayList<>();
for (Foo foo: fooList) {
fooPrimeList.add(new FooPrime().gamma(foo.getAlpha() + foo.getBeta()));
}
return fooPrimeList.toArray(new FooPrime[fooList.size()]);
}
private FooPrime[] testStreamToArray(ArrayList<Foo> fooList) {
return (FooPrime[]) fooList.stream().
map(it -> {
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).
toArray(FooPrime[]::new);
}
private FooPrime[] testStreamToArray2(ArrayList<Foo> fooList) {
return (FooPrime[]) fooList.stream().
map(it -> {
int stuff = it.getAlpha().length();
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).
toArray(FooPrime[]::new);
}
public static FooPrime fooToFooPrime(Foo foo) {
return new FooPrime().gamma(foo.getAlpha() + foo.getBeta());
}
public static class Foo {
private String alpha;
private String beta;
public String getAlpha() { return alpha; }
public String getBeta() { return beta; }
public void setAlpha(String alpha) { this.alpha = alpha; }
public void setBeta(String beta) { this.beta = beta; }
public Foo alpha(String alpha) { this.alpha = alpha; return this; }
public Foo beta(String beta) { this.beta = beta; return this; }
}
public static class FooPrime {
private String gamma;
public String getGamma() { return gamma; }
public void setGamma(String gamma) { this.gamma = gamma; }
public FooPrime gamma(String gamma) { this.gamma = gamma; return this; }
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((gamma == null) ? 0 : gamma.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
FooPrime other = (FooPrime) obj;
if (gamma == null) {
if (other.gamma != null)
return false;
} else if (!gamma.equals(other.gamma))
return false;
return true;
}
@Override
public String toString() {
return "FooPrime [gamma=" + gamma + "]";
}
}
}
和基类:
package timings;
public class TimingContainer {
private int iterations;
private String label;
private TimingTest timingTest;
public TimingContainer(int iterations, String label, TimingTest timingTest) {
this.iterations = iterations;
this.label = label;
this.timingTest = timingTest;
}
public void run() {
long startTime = System.nanoTime();
for (int ctr = 0; ctr < iterations; ++ ctr) {
timingTest.randomize();
timingTest.run();
}
long endTime = System.nanoTime();
long totalns = (endTime - startTime);
System.out.println(label + ":" + (totalns / iterations) + " ns");
}
}
最佳答案
(修改后的答案。)
Java 中的基准测试很困难。不过，让我们把 JMH 扔给它……我将您的基准移植到 JMH(请参阅 http://github.com/lemire/microbenchmarks)。
这些是相关的方法...
public FooPrime[] basicstream(BenchmarkState s) {
return (FooPrime[]) s.fooList.stream().map(it -> {
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).toArray(FooPrime[]::new);
}
public FooPrime[] tweakedbasicstream(BenchmarkState s) {
return (FooPrime[]) s.fooList.stream().map(it -> {
int stuff = it.getAlpha().length();
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).toArray(FooPrime[]::new);
}
这是我运行的结果...
git clone https://github.com/lemire/microbenchmarks.git
cd microbenchmarks
mvn clean install
java -cp target/microbenchmarks-0.0.1-jar-with-dependencies.jar me.lemire.microbenchmarks.mysteries.MysteriousLambda
Benchmark Mode Samples Score Error Units
m.l.m.m.MysteriousLambda.basicstream avgt 5 17013.784 ± 46.536 ns/op
m.l.m.m.MysteriousLambda.tweakedbasicstream avgt 5 16240.451 ± 67.884 ns/op
奇怪的是，这两个函数的运行平均速度似乎并不完全相同，而是存在相当显着的差异。那是在使用 JMH 时，一个相当不错的基准测试框架。
起初我以为你的两段代码在逻辑上是等价的，但它们不是。当返回的 String 对象为 null 时，显然无用的 length 方法访问会强制代码抛出异常。
所以其实更接近下面这段代码...
@Benchmark
public FooPrime[] nullbasicstream(BenchmarkState s) {
return (FooPrime[]) s.fooList.stream().map(it -> {
if( it.getAlpha() == null) throw new NullPointerException();
return new FooPrime().gamma(it.getAlpha() + it.getBeta());
}).toArray(FooPrime[]::new);
}
这比你调整后的函数还要快......
Benchmark Mode Samples Score Error Units
m.l.m.m.MysteriousLambda.basicstream avgt 5 17013.784 ± 46.536 ns/op
m.l.m.m.MysteriousLambda.nullbasicstream avgt 5 15983.762 ± 92.593 ns/op
m.l.m.m.MysteriousLambda.tweakedbasicstream avgt 5 16240.451 ± 67.884 ns/op
为什么会这样？
让我们绕开 Java 8 的流式编程并以愚蠢的旧方式编写函数，使用或不使用 null 检查:
@Benchmark
public FooPrime[] basicsum(BenchmarkState s) {
int howmany = s.fooList.size();
FooPrime[] answer = new FooPrime[s.fooList.size()];
for(int k = 0; k < howmany ; ++k ) {
Foo x = s.fooList.get(k);
answer[k] = new FooPrime(x.getAlpha() + x.getBeta());
}
return answer;
}
@Benchmark
public FooPrime[] basicsumnull(BenchmarkState s) {
int howmany = s.fooList.size();
FooPrime[] answer = new FooPrime[s.fooList.size()];
for(int k = 0; k < howmany ; ++k ) {
Foo x = s.fooList.get(k);
if(x.getAlpha() == null) throw new NullPointerException();
answer[k] = new FooPrime(x.getAlpha() + x.getBeta());
}
return answer;
}
这就是我们如何获得最佳性能...
m.l.m.m.MysteriousLambda.basicstream avgt 5 17019.730 ± 61.982 ns/op
m.l.m.m.MysteriousLambda.nullbasicstream avgt 5 16019.332 ± 62.831 ns/op
m.l.m.m.MysteriousLambda.basicsum avgt 5 15635.474 ± 119.890 ns/op
m.l.m.m.MysteriousLambda.basicsumnull avgt 5 14342.016 ± 109.958 ns/op
但是 null 检查的好处仍然存在。
好的。让我们对字符串总和进行基准测试，只是，没有其他任何东西(没有自定义类)。让我们同时拥有标准总和和之前进行空检查的总和:
@Benchmark
public void stringsum(BenchmarkState s) {
for(int k = 0; k < s.N; ++k) s.list3[k] = s.list1[k] + s.list2[k];
}
@Benchmark
public void stringsum_withexcept(BenchmarkState s) {
for(int k = 0; k < s.N; ++k) {
if(s.list1[k] == null) throw new NullPointerException();
s.list3[k] = s.list1[k] + s.list2[k];
}
}
我们知道 null 检查会减慢我们的速度......
m.l.m.m.StringMerge.stringsum avgt 5 27011.111 ± 4.077 ns/op
m.l.m.m.StringMerge.stringsum_withexcept avgt 5 28387.825 ± 82.523 ns/op
关于java - 为什么我的 java lambda 有一个虚拟赋值比没有它快得多？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/41622613/