我知道对 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/
类classAprivatedeffooputs:fooendpublicdefbarputs:barendprivatedefzimputs:zimendprotecteddefdibputs:dibendendA的实例a=A.new测试a.foorescueputs:faila.barrescueputs:faila.zimrescueputs:faila.dibrescueputs:faila.gazrescueputs:fail测试输出failbarfailfailfail.发送测试[:foo,:bar,:zim,:dib,:gaz].each{|m|a.send(m)resc
我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？ 最佳答案 通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co
我正在使用的第三方API的文档状态:"[O]urAPIonlyacceptspaddedBase64encodedstrings."什么是“填充的Base64编码字符串”以及如何在Ruby中生成它们。下面的代码是我第一次尝试创建转换为Base64的JSON格式数据。xa=Base64.encode64(a.to_json) 最佳答案 他们说的padding其实就是Base64本身的一部分。它是末尾的“=”和“==”。Base64将3个字节的数据包编码为4个编码字符。所以如果你的输入数据有长度n和n%3=1=>"=="末尾用于填充n%
我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i
使用带有Rails插件的vim，您可以创建一个迁移文件，然后一次性打开该文件吗？textmate也可以这样吗？ 最佳答案 你可以使用rails.vim然后做类似的事情::Rgeneratemigratonadd_foo_to_bar插件将打开迁移生成的文件，这正是您想要的。我不能代表textmate。 关于ruby-使用VimRails，您可以创建一个新的迁移文件并一次性打开它吗？，我们在StackOverflow上找到一个类似的问题： https://sta
我需要从一个View访问多个模型。以前，我的links_controller仅用于提供以不同方式排序的链接资源。现在我想包括一个部分(我假设)显示按分数排序的顶级用户(@users=User.all.sort_by(&:score))我知道我可以将此代码插入每个链接操作并从View访问它，但这似乎不是“ruby方式”，我将需要在不久的将来访问更多模型。这可能会变得很脏，是否有针对这种情况的任何技术？注意事项:我认为我的应用程序正朝着单一格式和动态页面内容的方向发展，本质上是一个典型的网络应用程序。我知道before_filter但考虑到我希望应用程序进入的方向，这似乎很麻烦。最终从任何
我想要做的是有2个不同的Controller，client和test_client。客户端Controller已经构建，我想创建一个test_clientController，我可以使用它来玩弄客户端的UI并根据需要进行调整。我主要是想绕过我在客户端中内置的验证及其对加载数据的管理Controller的依赖。所以我希望test_clientController加载示例数据集，然后呈现客户端Controller的索引View，以便我可以调整客户端UI。就是这样。我在test_clients索引方法中试过这个:classTestClientdefindexrender:template=>
为什么4.1%2返回0.0999999999999996？但是4.2%2==0.2。 最佳答案 参见此处:WhatEveryProgrammerShouldKnowAboutFloating-PointArithmetic实数是无限的。计算机使用的位数有限(今天是32位、64位)。因此计算机进行的浮点运算不能代表所有的实数。0.1是这些数字之一。请注意，这不是与Ruby相关的问题，而是与所有编程语言相关的问题，因为它来自计算机表示实数的方式。 关于ruby-为什么4.1%2使用Ruby返
它不等于主线程的binding，这个toplevel作用域是什么？此作用域与主线程中的binding有何不同？>ruby-e'putsTOPLEVEL_BINDING===binding'false 最佳答案 事实是，TOPLEVEL_BINDING始终引用Binding的预定义全局实例，而Kernel#binding创建的新实例>Binding每次封装当前执行上下文。在顶层，它们都包含相同的绑定(bind)，但它们不是同一个对象，您无法使用==或===测试它们的绑定(bind)相等性。putsTOPLEVEL_BINDINGput
我可以得到Infinity和NaNn=9.0/0#=>Infinityn.class#=>Floatm=0/0.0#=>NaNm.class#=>Float但是当我想直接访问Infinity或NaN时:Infinity#=>uninitializedconstantInfinity(NameError)NaN#=>uninitializedconstantNaN(NameError)什么是Infinity和NaN？它们是对象、关键字还是其他东西？ 最佳答案 您看到打印为Infinity和NaN的只是Float类的两个特殊实例的字符串