运用ForkJoin多线程框架实现归并排序

来源：互联网发布：系统优化的方法论编辑：程序博客网时间：2024/06/07 08:50

一、普通归并排序

public class MergeSort {
    /**
     * 原地归并排序（每次只将数组分为大和小两部分，并不是完全排序完成。需要递归）
     *
     * @param arr
     * @param lo
     * @param mid
     * @param hi
     */
    public void merge(int[] arr, int lo, int mid, int hi) {
        //1.复制数组
        int i = lo;
        int j = mid + 1;
        int[] temp = new int[arr.length];
        for (int k = lo; k <= hi; k++) {
            temp[k] = arr[k];
        }
        //2.移动指针进行排序（4种情况）
        for (int k = lo; k <= hi; k++) {
            if (i > mid) {//2.1 左边用尽
                arr[k] = temp[j++];
            } else if (j > hi) {//2.2 右边用尽
                arr[k] = temp[i++];
            } else if (temp[j] < temp[i]) {//2.3 左边大于右边
                arr[k] = temp[j++];
            } else {//2.4 右边大于左边
                arr[k] = temp[i++];
            }
        }
    }
    /**
     * 递归进行归并排序
     *
     * @param arr
     */
    public void sort(int[] arr) {
        sort(arr, 0, arr.length - 1);
    }
    public void sort(int[] arr, int lo, int hi) {
        if (hi <= lo) return;
        int mid = lo + (hi - lo) / 2;
        sort(arr,lo,mid);//左半边排序
        sort(arr,mid+1,hi);//右半边排序
        merge(arr,lo,mid,hi);//归并
    }
    // 生成一个数量为MAX的随机整数集合，准备计算数据
    private static int MAX = 100000;//100000个数进行排序
    private static int[] inits = new int[MAX];
    static {
        Random r = new Random();
        for(int index = 1 ; index <= MAX ; index++) {
            inits[index - 1] = r.nextInt(10000000);
        }
    }
    @Test
    public void testMerge() {
        long start = System.currentTimeMillis();
        sort(inits);
        long end = System.currentTimeMillis();
        //打印排序用时
        System.out.println(end - start);
    }
}

运行结果：

排序100000个随机数用了差不多5秒

二、ForkJoinPool实现归并排序

public class ConcurrentForkJoinMergeSort {
   private static int MAX = 100000;
    private static int inits[] = new int[MAX];
    // 同样进行随机队列初始化，这里就不再赘述了
    static {
        Random r = new Random();
        for(int index = 1 ; index <= MAX ; index++) {
            inits[index - 1] = r.nextInt(10000000);
        }
    }
    public static void main(String[] args) throws Exception {
        // 正式开始
        long beginTime = System.currentTimeMillis();
        ForkJoinPool pool = new ForkJoinPool();
        MyTask task = new MyTask(inits);
        ForkJoinTask<int[]> taskResult = pool.submit(task);
        try {
            taskResult.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace(System.out);
        }
        long endTime = System.currentTimeMillis();
        System.out.println("耗时=" + (endTime - beginTime));
    }
    /**
     * 单个排序的子任务
     */
    static class MyTask extends RecursiveTask<int[]> {
        private int source[];
        public MyTask(int source[]) {
            this.source = source;
        }
        /* (non-Javadoc)
         * @see java.util.concurrent.RecursiveTask#compute()
         */
        @Override
        protected int[] compute() {
            int sourceLen = source.length;
            // 如果条件成立，说明任务中要进行排序的集合还不够小
            if(sourceLen > 2) {
                int midIndex = sourceLen / 2;
                // 拆分成两个子任务
                MyTask task1 = new MyTask(Arrays.copyOf(source, midIndex));
                task1.fork();
                MyTask task2 = new MyTask(Arrays.copyOfRange(source, midIndex , sourceLen));
                task2.fork();
                // 将两个有序的数组，合并成一个有序的数组
                int result1[] = task1.join();
                int result2[] = task2.join();
                int mer[] = joinInts(result1 , result2);
                return mer;
            }
            // 否则说明集合中只有一个或者两个元素，可以进行这两个元素的比较排序了
            else {
                // 如果条件成立，说明数组中只有一个元素，或者是数组中的元素都已经排列好位置了
                if(sourceLen == 1
                        || source[0] <= source[1]) {
                    return source;
                } else {
                    int targetp[] = new int[sourceLen];
                    targetp[0] = source[1];
                    targetp[1] = source[0];
                    return targetp;
                }
            }
        }
        private int[] joinInts(int[] arr1, int[] arr2) {
            int left = 0;
            int right = 0;
            int[] mergeArr = new int[arr1.length + arr2.length];
            if(mergeArr.length == 0) return null;
            for (int i = 0; i < arr1.length + arr2.length; i++) {
                if(arr1.length == left) {
                    mergeArr[i] = arr2[right];
                    right++;
                    continue;
                }else if(arr2.length == right) {
                    mergeArr[i] = arr1[left];
                    left++;
                    continue;
                }
                if(arr1[left] <= arr2[right]){
                    mergeArr[i] = arr1[left];
                    left++;
                }else{
                    mergeArr[i] = arr2[right];
                    right++;
                }
            }
            return mergeArr;
        }
    }
}

运行结果：

排序100000个随机数只用了28毫秒

阅读全文

0 0