并发编程-线程池ForkJoinPool工作原理分析

由一道算法题引发的思考

算法题： 如何充分利用多核CPU的性能，快速 对一个2千万大小的数组进行排序？

分解 求解 合并

这道算法题可以拆解来看：

1）首先这是一道排序的算法题，而且是需要使用高效的排序算法对2千万大小的数组进行排序，可以考虑使用快速排序或者归并排序。

2）可以使用多线程并行排序算法来充分利用多核CPU的性能。

2. 基于归并排序算法实现

对于大小为2千万的数组进行快速排序，可以使用高效的归并排序算法来实现。

2.1 什么是归并排序

归并排序（Merge Sort）是一种基于分治思想的排序算法 。 归并排序的基本思想是将一个大数组分成 两个相等大小的子数组，对每个子数组分别进行排序，然后将两个子数组合并成一个有序的大数组。

因为常常使用递归实现(由先拆分后合并的性质决定的)，所以我们称其为归并排序。

归并排序的步骤包括以下几个方面：

         1.将数组分成两个子数组

        2.对每个子数组进行排序合并两个有序的子数组

        3.合并两个有序的子数组

归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)，其中n为数组的长度。

分治思想是 将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题

性质相同。求出子问题的解，就可得到原问题的解。

分治思想的步骤如下：

        1. 分解 ：将要解决的问题划分成若干规模较小的同类问题；

        2. 求解 ：当子问题划分得足够小时，用较简单的方法解决；

        3. 合并 ：按原问题的要求，将子问题的解逐层合并构成原问题的解。

计算机十大经典算法中的归并排序、快速排序、二分查找都是基于分治思想实现的算法

分治任务模型图如下：

2.2 归并排序动图演示

归并排序演示： https://www.cs.usfca.edu/~galles/visualization/ComparisonSort.html

2.3 使用归并排序实现上面的算法题

单线程实现归并排序

        单线程归并算法的实现，它的基本思路是将序列分成两个部分，分别进行递归排序，然后将排序好的 子序列合并起来

public class MergeSort {

    private final int[] arrayToSort; //要排序的数组
    private final int threshold; //拆分的阈值，低于此阈值就不再进行拆分

    public MergeSort(final int[] arrayToSort, final int threshold) {
        this.arrayToSort = arrayToSort;
        this.threshold = threshold;
    }

    /**
     * 排序
     *
     * @return
     */
    public int[] sequentialSort() {
        return sequentialSort(arrayToSort, threshold);
    }

    public static int[] sequentialSort(final int[] arrayToSort, int threshold) {
        //拆分后的数组长度小于阈值，直接进行排序
        if (arrayToSort.length < threshold) {
            //调用jdk提供的排序方法
            Arrays.sort(arrayToSort);
            return arrayToSort;
        }

        int midpoint = arrayToSort.length / 2;
        //对数组进行拆分
        int[] leftArray = Arrays.copyOfRange(arrayToSort, 0, midpoint);
        int[] rightArray = Arrays.copyOfRange(arrayToSort, midpoint,
                arrayToSort.length);
        //递归调用
        leftArray = sequentialSort(leftArray, threshold);
        rightArray = sequentialSort(rightArray, threshold);
        //合并排序结果
        return merge(leftArray, rightArray);
    }

    public static int[] merge(final int[] leftArray, final int[] rightArray) {
        //定义用于合并结果的数组
        int[] mergedArray = new int[leftArray.length + rightArray.length];
        int mergedArrayPos = 0;
        int leftArrayPos = 0;
        int rightArrayPos = 0;
        while (leftArrayPos < leftArray.length && rightArrayPos < rightArray.length) {
            if (leftArray[leftArrayPos] <= rightArray[rightArrayPos]) {
                mergedArray[mergedArrayPos] = leftArray[leftArrayPos];
                leftArrayPos++;
            } else {
                mergedArray[mergedArrayPos] = rightArray[rightArrayPos];
                rightArrayPos++;
            }
            mergedArrayPos++;
        }

        while (leftArrayPos < leftArray.length) {
            mergedArray[mergedArrayPos] = leftArray[leftArrayPos];
            leftArrayPos++;
            mergedArrayPos++;
        }

        while (rightArrayPos < rightArray.length) {