使用Fork/Join框架优化归并排序

Fork/Join框架是一个非常有意思的并发框架，它非常适合于处理类似归并排序这种将大的问题分解成多个小问题，并将结果进行合并的情况，这次我们就使用Fork/Join框架来优化我们的归并排序。查看更多有关Fork/Join框架的知识，请点击这里;

首先为了与普通单线程归并排序对比，我们先来写一个传统的归并排序：

import java.util.Arrays;

public class Test {
    private int[] array;

    public Test(int[] array){
        this.array = array;
    }

    public void sort(){
        if (array.length < 2) {
           return;
        }
        int middle = (int)(array.length)/ 2;

        int[] left = Arrays.copyOfRange(array, 0, middle);
        int[] right = Arrays.copyOfRange(array, middle, array.length);

        Test t1 = new Test(left);
        t1.sort();
        Test t2 = new Test(right);
        t2.sort();

        merge(left, right);
   }

   private void merge(int[] left, int[] right) {
        int i = 0,j = 0,m = 0; 
        while (i < left.length && j < right.length) {
            if(left[i] <= right[j]){ 
                array[m] = left[i];
                i++;
            }else{
                array[m] = right[j];
                j++;
            }
            m++;
        }

        while (i < left.length) {
            array[m] = left[i];
           i++;m++;
        }

        while (j < right.length) {
            array[m] = right[j];
            j++;m++;
        }
   }
}

下面来写一个使用Fork/Join框架的归并排序：

import java.util.Arrays;
import java.util.concurrent.RecursiveAction;

public class Tesk extends RecursiveAction{

    private static final long serialVersionUID = 6876633274768462482L;
    private int[] array;

    public Tesk(int[] array){
        this.array = array;
    }

    @Override
    protected void compute() {
        if(array.length < 2){
            return;
        }else{
            int mid = (int)(array.length)/2;
            int[] left = Arrays.copyOfRange(array, 0, mid);
            int[] right = Arrays.copyOfRange(array, mid, array.length);
            Tesk t1 = new Tesk(left);
            Tesk t2 = new Tesk(right);
            invokeAll(t1, t2);
            merge(left, right);
        }
    }

    private void merge(int[] left, int[] right) {
        int i = 0,j = 0,m = 0; 
        while (i < left.length && j < right.length) {
             if(left[i] <= right[j]){
                 array[m] = left[i];
                 i++;
             }else{
                array[m] = right[j];
                 j++;
             }
             m++;
        }
 
         while (i < left.length) {
            array[m] = left[i];
            i++;m++;
         }
 
         while (j < right.length) {
            array[m] = right[j];
            j++;m++;
         }
    }

}

使用方式：

ForkJoinPool pool = new ForkJoinPool();
Tesk task = new Tesk(array);
pool.invoke(task);

在写法上我尽量使两者保持一致，比如都是将需要排序的数组作为构造参数，并且会直接在原数组上修改为排好序的数组。

我的电脑是双核的，使用了一千万个数据做测试，最终普通归并排序平均大概使用了1350ms，使用了Fork/Join框架的归并排序平均大概使用了1050ms。如果使用更多的数字这个差距还会更明显，比如又测试了三千万个数字，性能大概提升了1000ms。虽然排序时间受很多因素影响，但是还是可以看出来Fork/Join框架对归并排序的优化的。特别是数据特别多的时候，如果这个时候电脑是多核的不妨使用Fork/Join来提升排序速度。