关于这个问题有很多不清楚的地方.这些是显而易见的事情,例如您如何运行时序测试,如何提供输入数字,以及输入数字的大小.
此外,当你说在Java 7中存储2 * 100000个整数对象应该只需要112KB时,必然会涉及一些魔法压缩,因为数据本身已经占用至少800 KB,忽略了任何进一步的对象开销.此外,对于您提到的数字,排序甚至不应该花费373ms,但在现代PC上可能只需要50ms.
但是,评论中有一些提示我会尝试在这里汇总,希望它会被认为是有用的(甚至可能回答你的问题).
首先,微基准测试是一门艺术,需要考虑很多事情.为了获得“可靠”的结果,您必须使用像JMH或Caliper这样的微基准测试工具包.但是为了快速得到结果的粗略近似值,您至少应该多次重复实际测试.对于您的情况,这大致可以这样做:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
public class SortingSpeedTest {
private static List createList(int n, int offset, int range) {
Random random = new Random(0);
List list = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
list.add(random.nextInt(range) + offset);
}
return list;
}
public static void main(String[] args) {
for (int m = 1000; m <= 1000000; m *= 10) {
for (int n = 1000; n <= 1000000; n *= 10) {
runTest(m, n);
}
}
}
private static void runTest(int m, int n) {
List list1 = createList(m, 0, 100);
List list2 = createList(n, 100, 100);
long before = System.nanoTime();
Collections.sort(list1);
Collections.sort(list2, Collections.reverseOrder());
int max = Math.min(list1.size(), list2.size());
int a, b;
long result = 0;
for (int i = 0; i < max; i++) {
a = list1.get(i);
b = list2.get(i);
if (b > a)
result += (b - a);
else
break;
}
long after = System.nanoTime();
System.out.printf("m=%7d n=%7d result=%14d duration %8.3f\n", m, n,
result, (after - before) / 1e6);
}
}
在我的机器上(在这里省略一些细节,因为可靠性不是太高),当使用-Xmx1500m -server启动时,这给出了Java 7的以下结果
m= 1000 n= 1000 result= 100000 duration 5,985
m= 1000 n= 10000 result= 144379 duration 26,641
m= 1000 n= 100000 result= 149303 duration 38,308
m= 1000 n=1000000 result= 149336 duration 148,365
m= 10000 n= 1000 result= 145269 duration 9,068
m= 10000 n= 10000 result= 1000000 duration 11,799
m= 10000 n= 100000 result= 1450247 duration 16,218
m= 10000 n=1000000 result= 1494798 duration 134,486
m= 100000 n= 1000 result= 149664 duration 18,795
m= 100000 n= 10000 result= 1449668 duration 18,451
m= 100000 n= 100000 result= 10000000 duration 27,568
m= 100000 n=1000000 result= 14490326 duration 149,033
m=1000000 n= 1000 result= 149664 duration 153,541
m=1000000 n= 10000 result= 1495165 duration 129,903
m=1000000 n= 100000 result= 14510529 duration 141,377
m=1000000 n=1000000 result= 100000000 duration 278,689
这些结果在Java 8中:
m= 1000 n= 1000 result= 100000 duration 4,271
m= 1000 n= 10000 result= 144379 duration 10,414
m= 1000 n= 100000 result= 149303 duration 45,413
m= 1000 n=1000000 result= 149336 duration 179,397
m= 10000 n= 1000 result= 145269 duration 7,422
m= 10000 n= 10000 result= 1000000 duration 6,464
m= 10000 n= 100000 result= 1450247 duration 54,259
m= 10000 n=1000000 result= 1494798 duration 158,869
m= 100000 n= 1000 result= 149664 duration 17,863
m= 100000 n= 10000 result= 1449668 duration 16,904
m= 100000 n= 100000 result= 10000000 duration 33,613
m= 100000 n=1000000 result= 14490326 duration 158,988
m=1000000 n= 1000 result= 149664 duration 133,977
m=1000000 n= 10000 result= 1495165 duration 139,210
m=1000000 n= 100000 result= 14510529 duration 156,483
m=1000000 n=1000000 result= 100000000 duration 1080,306
您可以看到结果大致相等,除了最后一个.再次启动它,另外指定-verbose:gc显示原因:
...
m=1000000 n= 100000 result= 14510529 duration 156,934
...
[Full GC (Ergonomics) 64237K->24095K(79360K), 0.7443466 secs]
m=1000000 n=1000000 result= 100000000 duration 1056,624
它在最后一次传递之前执行完整的垃圾收集. (当使用上述基准测试框架之一时,可以避免这样的事情!).
现在可以开始一些GC调整,并且有许多关于此的文章(这不仅是一门艺术,这是一种黑色艺术).但GC的实际原因可以从程序中得出:它创建了许多必须清理的Integer对象.
根据这些列表中Integer对象的大小,可以避免这种情况.从int到Integer的自动装箱内部依赖于“小”int值的缓存.此缓存的默认大小相当小.但是当使用-XX:AutoBoxCacheMax = 300启动上述程序时,几乎所有GC暂停都将消失,因为在此测试中根本没有大于300的Integer值.
旁白:这是对程序的简单修改以使用并行流
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Random;
import java.util.stream.Collectors;
public class ParallelSortingSpeedTest {
private static List createList(int n, int offset, int range) {
Random random = new Random(0);
List list = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
list.add(random.nextInt(range) + offset);
}
return list;
}
public static void main(String[] args) {
for (int m = 1000; m <= 1000000; m *= 10) {
for (int n = 1000; n <= 1000000; n *= 10) {
runTest(m, n);
}
}
}
private static void runTest(int m, int n) {
List list1 = createList(m, 0, 100);
List list2 = createList(n, 100, 100);
long before = System.nanoTime();
list1 = list1.parallelStream().sorted().collect(Collectors.toList());
list2 = list2.parallelStream().sorted(
Collections.reverseOrder()).collect(Collectors.toList());
int max = Math.min(list1.size(), list2.size());
int a, b;
long result = 0;
for (int i = 0; i < max; i++) {
a = list1.get(i);
b = list2.get(i);
if (b > a)
result += (b - a);
else
break;
}
long after = System.nanoTime();
System.out.printf("m=%7d n=%7d result=%14d duration %8.3f\n", m, n,
result, (after - before) / 1e6);
}
}
在这种情况下,您甚至可以观察到Java 8的轻微加速:
....
m=1000000 n= 10000 result= 1495165 duration 95,386
m=1000000 n= 100000 result= 14510529 duration 95,467
m=1000000 n=1000000 result= 100000000 duration 172,782