数组排序与并行排序性能比较

Question

我已下载java8-ea版本，并在Array.sort和Arrays.parallelSort之间进行了快速比较。

这就是结果：

我可以理解，praralleSort应至少表现为普通的sort，如果不是更快......但这不是发生的事情。

对以下规格进行了比较：

HP ProBook Intel Core i5 4G RAM Ubuntu 13.04 Linux，JDK版本为：Java HotSpot(TM) 64-Bit Server VM (build 25.0-b23, mixed mode)

我通过这种方式创建了一个包含三个字段的Custom对象数组（按保留顺序添加对象）：

package com.cmd;

import java.util.Arrays;

public class Main {

    public static void main(String[] args) {

        for (int i=100; i <= 10_000_000; i*=10){
            runTest(i);
        }
    }

    private static void runTest(final int size){

        // Fist obtain two Arrays of same data
        Employee[] empArrForSort = createVeryLargeEmpArray(size);
        Employee[] empArrForSortCopy = Arrays.copyOf(empArrForSort, empArrForSort.length);

        long start = System.currentTimeMillis();
        Arrays.sort(empArrForSort, (e1, e2) -> new Integer(e1.getId()).compareTo(e2.getId()));
        logStart(size + ": sort", start);

        start = System.currentTimeMillis();
        Arrays.parallelSort(empArrForSortCopy, (e1, e2) -> new Integer(e1.getId()).compareTo(e2.getId()));
        logStart(size + ": parallel sort", start);
    }


    private static void logStart(String label, long startTimeMillis) {
        System.out.println("End " + label + " the array. It took: " + (System.currentTimeMillis() - startTimeMillis) + " ms");
    }

    private static Employee[] createVeryLargeEmpArray(final int size) {

        Employee[] ret = new Employee[size];

        for (int i = 0; i < ret.length; i++) {
            ret[i] = Employee.createEmployee(ret.length - i, "Mohammad" + i, "");
        }

        return ret;
    }

    static class Employee {

        private int id;
        private String name;
        private String email;

        private Employee(int id, String name, String email) {
            this.id = id;
            this.name = name;
            this.email = email;
        }

        public static Employee createEmployee(int id, String name, String email) {
            return new Employee(id, name, email);
        }

        public int getId() {
            return id;
        }
    }

}

并且，另一个运行显示，Parallel仅在列表包含10,000,000时执行填充，在所有其他情况下它看起来更好。

>java -Xmx2000m com.cmd.Main
End 100: sort the array. It took: 110 ms
End 100: parallel sort the array. It took: 6 ms
End 1000: sort the array. It took: 2 ms
End 1000: parallel sort the array. It took: 3 ms
End 10000: sort the array. It took: 11 ms
End 10000: parallel sort the array. It took: 11 ms
End 100000: sort the array. It took: 15 ms
End 100000: parallel sort the array. It took: 37 ms
End 1000000: sort the array. It took: 553 ms
End 1000000: parallel sort the array. It took: 187 ms
End 10000000: sort the array. It took: 640 ms
End 10000000: parallel sort the array. It took: 1099 ms

Answer 1

这里的要点是数组按保留顺序排序。 这是一个非常独特的场景，并不意味着算法的一般性能。 我使用无序数组运行相同的代码：

  ret[i] = Employee.createEmployee(rnd.nextInt(ret.length), "Mohammad" + i, "");

当parallelSort比简单排序快得多时，结果显示性能要慢得多。

End 100: sort the array. It took: 139 ms
End 100: parallel sort the array. It took: 4 ms
End 1000: sort the array. It took: 4 ms
End 1000: parallel sort the array. It took: 6 ms
End 10000: sort the array. It took: 35 ms
End 10000: parallel sort the array. It took: 30 ms
End 100000: sort the array. It took: 420 ms
End 100000: parallel sort the array. It took: 144 ms
End 1000000: sort the array. It took: 1341 ms
End 1000000: parallel sort the array. It took: 506 ms
End 10000000: sort the array. It took: 12200 ms
End 10000000: parallel sort the array. It took: 3971 ms

Answer 2

在createVeryLargeEmpArray方法中仅修改了2行，如下所示。

Random random = new Random();
ret[i] = Employee.createEmployee(ret.length - i+random.nextInt(size), "Mohammad" + i, "");

以下是结果

结束100：对数组进行排序。花了：27毫秒 结束100：对数组进行并行排序。花了1毫秒

结束1000：对数组进行排序。花了：1毫秒 结束1000：对数组进行并行排序。花了1毫秒

结束10000：对数组进行排序。花了7毫秒 结束10000：并行排序数组。花了145毫秒

结束100000：对数组进行排序。花了：105毫秒 结束100000：并行排序数组。花了59毫秒

结束1000000：对数组进行排序。花了：1050毫秒 结束1000000：并行排序数组。花了：194毫秒

结束10000000：对数组进行排序。花了：12636毫秒
结束10000000：并行排序数组。花了：2107毫秒

随着未排序元素的数量增加，并行排序开始比常规排序好很多。

Answer 3

我已经创建了大量测试，在绝大多数情况下，parallelSort的性能远远优于（串行）排序。