java 性能排序_Java 8性能不佳,排序

最新推荐文章于 2021-03-05 00:37:51 发布

钱有用

最新推荐文章于 2021-03-05 00:37:51 发布

阅读量105

点赞数

文章标签： java 性能排序

本文链接：https://blog.csdn.net/weixin_36205997/article/details/115041328

版权

关于这个问题有很多不清楚的地方.这些是显而易见的事情,例如您如何运行时序测试,如何提供输入数字,以及输入数字的大小.

此外,当你说在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值.

旁白：这是对程序的简单修改以使用并行流