Oracle vs IBM Java性能

Question

我试图比较两个主要Java实现的性能：Oracle和IBM运行以下测试：

public class HarmonicSeriesTest {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        final int limit = 20;
        double sum = 0.0;
        long n = 0;
        while (sum < limit) {
            n++;
            sum += 1.0 / n;
        }
        long duration = System.currentTimeMillis() - startTime;
        System.out.printf("n is %d\n", n);
        System.out.printf("Executed in %d miliseconds\n", duration);
    }
}

通过以下方式运行上述代码：

1. IBMJRE 1.8.0

java版本“1.8.0”java（TM）SE运行时环境（build pwa6480sr3fp22-20161213\U 02（SR3 FP22））IBM J9 VM（build 2.8，JRE 1.8.0 Windows 10 amd64-64压缩引用20161209\U 329148（JIT启用，AOT启用）J9VM-R28\U 20161209\U 1345\U B329148 JIT-tr.r14。Java语言green\u 20161207\u 128946 GC-R28\u 20161209\u 1345\u B329148\u CMPRSS J9CL-20161209\u 329148）JCL-20161213\u 01基于Oracle jdk8u111-b14

java版本“1.8.0\u 131”java（TM）SE运行时环境（build 1.8.0\u 131-b11）java HotSpot（TM）64位服务器VM（build 25.131-b11，混合模式）

Java版本"1.5.0_22"Java（TM）2运行时环境，标准版（构建1.5.0_22-b03）JavaHotSpot（TM）64位服务器VM（构建1.5.0_22-b03，混合html" target="_blank">模式）

我始终得到以下结果：

1. IBM JRE 1.8.0编译器合规性级别1.8

n is 272400600
Executed in 1024 miliseconds

n is 272400600
Executed in 2002 miliseconds

n is 272400600
Executed in 1506 miliseconds

如您所见，Oracle JRE比IBM JRE慢100%，比Sun JRE慢25%。Oracle和IBM实现之间的差距很大，而且Oracle JRE看起来像是对Sun JRE的回归。

有人能解释为什么Java的“官方”实现如此缓慢吗？

我对使用JMH没有兴趣，因为我不想对任何东西进行基准测试。

下面是我用于测试的硬件配置：

Answer 1

首先，我不是一个性能专家，但我和JMH打交道。

最好在像JMH这样的工具中测试它，它可以让你比较苹果和苹果。

不同的Java运行时将更快地启动，并在以后进行优化。例如，可以展开一个循环，热点将进入。

只运行一次测试不会得到准确的样本。i、 e.代码运行得越多，速度就越快。有一个C1、C2、JIT和一系列不同供应商实现的魔术，使代码运行得越来越快。

以下是在JHM中创建项目的步骤，希望能帮助您比较苹果与苹果。

>

mvn-DarchetypeGroupId=组织。openjdk。jmh-DarchetypeArtifactId=jmh java基准原型-DarchetypeVersion=1.18-DarchetypeRepository=http://repo.maven.apache.org/maven2/-DgroupId=com。您的公司-DartifactId=HarmonicSeriest-Dversion=1.0-快照-Dpackage=com。您的公司。HarmonicSeriest-Darchetype。interactive=false--批处理模式原型：generate

构建项目

CD HarmonicSeriesTest/

MVN包

编辑生成的类

编辑MyBenchmark。Java语言

import java.util.concurrent.TimeUnit;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.OutputTimeUnit;

public class MyBenchmark {
    @Benchmark
    @BenchmarkMode(Mode.AverageTime)
    @OutputTimeUnit(TimeUnit.MILLISECONDS)
    public double harmonicSeriesTest() {
        final int limit = 20;
        double sum = 0.0;
        long n = 0;
        while (sum < limit) {
            n++;
            sum += 1.0 / n;
        }
        return sum;
    }

}

4、在命令行上运行项目，而不是在IDE上运行，因为这可能会影响事情

在命令行上执行：

mvn package
cd target
java -jar benchmarks.jar

我的输出。正如您所看到的，第一次迭代很慢，然后又加速了。寻找预热后的第一次迭代，因为这是您应该跨Java实现和使用不同JVM标志进行比较的值。

JMH 1.18 (released 61 days ago)
VM version: JDK 1.8.0_102, VM 25.102-b14
VM invoker: /home/richard/install/java/jdk1.8.0_102/jre/bin/java
VM options: <none>
Warmup: 20 iterations, 1 s each
Measurement: 20 iterations, 1 s each
Timeout: 10 min per iteration
Threads: 1 thread, will synchronize iterations
Benchmark mode: Average time, time/op
Benchmark: com.yourcompany.harmonicseriestest.MyBenchmark.harmonicSeriesTest

Run progress: 0.00% complete, ETA 00:06:40
Fork: 1 of 10
Warmup Iteration   1: 1773.454 ms/op
Warmup Iteration   2: 1782.517 ms/op
Warmup Iteration   3: 1545.739 ms/op
Warmup Iteration   4: 1542.968 ms/op
Warmup Iteration   5: 1530.740 ms/op
Warmup Iteration   6: 1539.304 ms/op
Warmup Iteration   7: 1538.079 ms/op
Warmup Iteration   8: 1535.280 ms/op
Warmup Iteration   9: 1547.716 ms/op
Warmup Iteration  10: 1520.056 ms/op
Warmup Iteration  11: 1503.892 ms/op
Warmup Iteration  12: 1513.037 ms/op
Warmup Iteration  13: 1521.966 ms/op
Warmup Iteration  14: 1519.931 ms/op
Warmup Iteration  15: 1515.179 ms/op
Warmup Iteration  16: 1514.342 ms/op
Warmup Iteration  17: 1525.555 ms/op
Warmup Iteration  18: 1519.022 ms/op
Warmup Iteration  19: 1533.529 ms/op
Warmup Iteration  20: 1525.547 ms/op
Iteration   1: 1524.958 ms/op

注意：这些是测试JVM的黄金样本。微观基准比较棘手，很容易做出“错误”的基准。

还可以看看Nitsan这样的博客和Aleksey Shipilev这样的幻灯片，因为他们真的知道自己在做什么：）。