【发布时间】：2023-04-10 10:10:02
【问题描述】：
我不想再引发一场关于 Java 还是 C++ 是总体上更好的语言的无意义的争论。我想知道我为特定任务所做的比较是否公平，测量的数据是否正确。
我们需要决定下一个项目是使用 Java 还是 C++。我在 C++ 阵营，但我想为我的案例提供可靠的论据。我们的应用比较特殊，有以下需求：
- 程序必须运行得相当快并且内存效率相当高。我们不关心最后 20% 的表现。但是，10 倍的性能差异是无法展示的。
- 我们有很多阵列。我们预先不知道它们的大小。因此，数组可以在平均 O(1) 的运行时间内增长，这一点很重要。
- 数组中的元素由少量基本数据类型组成。典型的例子是整数或浮点数的元组。
- 数组可能会变大。 10^6 个元素是标准的。我们有包含 10^7 个元素的应用程序，支持 10^8 会很棒。
我用 C++ 和 Java 实现了一个玩具程序。首先，我介绍一下 C++ 版本：
#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
struct Point{
float x, y;
};
int main(int argc, char*argv[]){
int n = atoi(argv[1]);
vector<Point>arr;
for(int i=0; i<n; ++i){
Point p;
p.x = i;
p.y = i+0.5f;
arr.push_back(p);
}
float dotp = 0;
for(int i=0; i<n; ++i)
dotp += arr[i].x * arr[i].y;
cout << dotp << endl;
}
接下来是做同样事情的Java版本：
import java.util.*;
class Point{
public float x, y;
}
class Main{
static public void main(String[]args){
int n = Integer.parseInt(args[0]);
ArrayList<Point> arr = new ArrayList<Point>();
for(int i=0; i<n; ++i){
Point p = new Point();
p.x = i;
p.y = i+0.5f;
arr.add(p);
}
float dotp = 0;
for(int i=0; i<n; ++i)
dotp += arr.get(i).x * arr.get(i).y;
System.out.println(dotp);
}
}
我使用命令行将元素的数量传递给程序，以防止优化器在编译期间执行程序。计算的值没有用。唯一有趣的问题是程序运行速度有多快以及它们使用了多少内存。我从 C++ 开始：
$ g++ --version
g++ (Ubuntu 4.8.4-2ubuntu1~14.04.3) 4.8.4
$ g++ -O3 test.cpp -o test
$ /usr/bin/time ./test 1000000
3.33381e+17
0.01user 0.00system 0:00.02elapsed 100%CPU (0avgtext+0avgdata 10084maxresident)k
0inputs+0outputs (0major+2348minor)pagefaults 0swaps
$ /usr/bin/time ./test 10000000
3.36984e+20
0.08user 0.01system 0:00.09elapsed 100%CPU (0avgtext+0avgdata 134380maxresident)k
0inputs+0outputs (0major+4074minor)pagefaults 0swaps
$ /usr/bin/time ./test 100000000
2.42876e+23
0.77user 0.09system 0:00.87elapsed 99%CPU (0avgtext+0avgdata 1050400maxresident)k
0inputs+0outputs (0major+6540minor)pagefaults 0swaps
“用户”时间是程序运行的时间。对于 10^6 个元素，它运行了 0.01 秒，对于 10^7 个元素为 0.08 秒，对于 10^8 个元素为 0.77 秒。 “maxresident”是内核给程序的物理内存量，以千字节为单位。 10^6 为 10 MB，10^7 为 132 MB，10^8 为 1 GB。
内存消耗听起来不错。具有 x 个元素的数组需要 sizeof(float)*2*x=8*x 字节的内存。 10^6 元素大约 8MB，10^7 大约 76MB，10^8 大约 762MB。
接下来，我运行 Java 程序：
$ javac -version
javac 1.6.0_41
$ javac Main.java
$ java -version
java version "1.7.0_131"
OpenJDK Runtime Environment (IcedTea 2.6.9) (7u131-2.6.9-0ubuntu0.14.04.2)
OpenJDK 64-Bit Server VM (build 24.131-b00, mixed mode)
$ /usr/bin/time java Main 1000000
3.33381168E17
0.16user 0.00system 0:00.09elapsed 173%CPU (0avgtext+0avgdata 79828maxresident)k
0inputs+64outputs (0major+4314minor)pagefaults 0swaps
$ /usr/bin/time java Main 10000000
3.3698438E20
5.23user 0.18system 0:02.07elapsed 261%CPU (0avgtext+0avgdata 424180maxresident)k
0inputs+64outputs (0major+13508minor)pagefaults 0swaps
$ /usr/bin/time java Main 100000000
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
at Main.main(Main.java:14)
Command exited with non-zero status 1
3840.72user 13.06system 17:11.79elapsed 373%CPU (0avgtext+0avgdata 2281416maxresident)k
0inputs+1408outputs (0major+139893minor)pagefaults 0swaps
对于 10^6 个元素，它需要 0.16 秒和 78 MB。对于 10^7 个元素，它需要 5.23 秒和 414 MB。我试图为 10^8 个元素运行该程序，但 Java 崩溃了。它使用了我机器的所有内核（在一个顺序程序中！）并运行了 17 分钟，同时占用了 2.2GB。我的机器有 8 GB 内存。
对于 10^6 个元素，C++ 的速度是 0.16 / 0.01 = 16 倍，并且需要 78/10 = 7.8 倍的内存。对于 10^7 个元素，C++ 的速度是 5.23/0.08 = 65 倍，并且需要 414/132 = 3.1 倍的内存。 Java 没有在具有 10^8 个元素的测试实例上完成，而 C++ 程序在不到一秒的时间内完成。
对于 10^6，Java 似乎易于管理，但并不理想。对于 10^7 和 10^8，这是绝对不行的。我预计 C++ 相对于 Java 有轻微的性能优势，但不会有这么大的优势。
最可能的解释是我的测试方法有误，或者我的 Java 代码存在不明显的性能瓶颈。另一种解释是 OpenJDK JVM 明显落后于其他供应商的 JVM。
请向我解释为什么 Java 在这个基准测试中表现如此糟糕。我是如何无意中让 Java 看起来比实际更糟糕的？
谢谢
【问题讨论】：
-
使 C++ 版本快得多的一件事是
Point对象直接存储在向量的堆分配中，而在 Java 版本中，每个Point对象需要完全独立的堆分配。我建议使用带有struct Point（不是class Point）和List<Point>的C# 进行另一个基准测试，因为这更接近于C++ 代码中发生的情况——Point对象将被分配在单个数组中作为单独的堆对象。 -
这里一个非常明显和很大的区别是
vector<Point>只是一堆点，而ArrayList<Point>是一堆对点的引用。您可以使用int[]/float[]/etc（仅使用原语数组）来模拟直接数据，但当然您必须手动增长它.. -
@TrevorHart 不，这根本不是真的。一个好的 JIT 可以在许多工作流中击败静态编译的代码。 C++ 提供控制 性能，而不是性能。甚至配置文件引导的优化仍然是静态编译，并且仅针对某些参数进行优化，因为 JIT 可以即时适应不同的工作流程。
-
@KlitosKyriacou 这就是“摊销”的意思。因为向量的增长因子，它仍然是常数时间。
-
是的，对大型结构类对象的大型数组的高性能需求是 imo 最弱的 Java 用例（以及任何其他不支持内部结构数组的语言）。是的，
vector<unique_ptr<Point>>产生了一个类似于 Java 的内部 C++ 代表，但关键是你不能在 Java 中描述vector<Point>的等价物。在其他领域，Java 有优势，但如果这个用例对您的应用程序至关重要，那么您应该很容易赢得争论。
标签： java c++ arrays performance arraylist