Java多线程排序

 我们知道多线程时Java的重要特点之一，而排序是我们日常见到最多的操作。那么如何将多线程和排序结合起来呢？

首先我们需要把传入的数组A分为若干个小数组：比如数组1，数组2。再将这若干个小数组分别进行排序，最后再归并排序到一个数组之中。

🌟具体步骤：

（1）我们将原数组的前部分给数组1，后部分给数组2。分别对1、2数组进行排序。

 （2）我们再进行归并排序：将数组1的第一位就是1，和数组2的第一位就是5进行比较。显而易见是1小，所以我们将1提出到新数组中就会是【1】

归并后的结果数组：【1】

 （3）我们将数组1的第一位现在是2，和数组2的第一位还是5进行比较。显而易见是2小，所以我们将2提出到新数组中就会是【1，2】

归并后的结果数组：【1，2】

（4）以此类推：我们就得到了归并后的最终数组【1，2，3，4，5，6，7，8，9，10】

归并后的结果数组：【1，2，3，4，5，6，7，8，9，10】

🌟代码实现：

本程序总共使用三个类，分别是排序算法、排序线程、测试排序程序组成。在测试排序程序中生成了10个随机数，启用2个线程进行排序。

SortService排序算法

public class SortService {
    private CyclicBarrier barrier;
    private int size;// 父数组大小
    private int subThreads = 2;// 子线程数量
    private int[] array;// 父数组
    private int[][] subArray;// 子数组
    private int[] sortedArray;// 最终排序好的数组
    public SortService(int[] array) {
        this.array = array;
        this.size = array.length;
    }
    public void printSortedArray() throws Exception {//输出排序好的数组
        init();//初始化子数组
        for (int i = 0; i < subThreads; i++) {
            SortTask sortTask = new SortTask(barrier, subArray[i]);
            Thread thread = new Thread(sortTask);
            thread.start();
        }
        barrier.await();
        mergeSubArray();
        System.out.println("排序之后的数组 : " + Arrays.toString(sortedArray));
    }
    private void init() {// 初始化数组，并将父数组拆分为两个子数组
        barrier = new CyclicBarrier(subThreads + 1);
        subArray = new int[subThreads][];
        subArray[0] = new int[size / 2];
        if (size % 2 == 0) {
            subArray[1] = new int[size / 2];
        } else
            subArray[1] = new int[size / 2 + 1];
        System.arraycopy(array, 0, subArray[0], 0, subArray[0].length);
        System.arraycopy(array, subArray[0].length, subArray[1], 0, subArray[1].length);
    }
    private void mergeSubArray() {// 合并子数组
        sortedArray = new int[size];
        int i = 0, j = 0, k = 0;
        while (j < subArray[0].length && k < subArray[1].length) {
            if (subArray[0][j] <= subArray[1][k]) {
                sortedArray[i++] = subArray[0][j++];
            } else
                sortedArray[i++] = subArray[1][k++];
        }
        while (j < subArray[0].length)
            sortedArray[i++] = subArray[0][j++];
        while (k < subArray[1].length)
            sortedArray[i++] = subArray[1][k++];
    } }

SortTask排序线程 

public class SortTask implements Runnable {
    private CyclicBarrier barrier;
    private int[] array;
    public SortTask(CyclicBarrier barrier, int[] array) {
        this.barrier = barrier;
        this.array = array;
    }
    @Override
    public void run() {
        Arrays.sort(array);
        try {
            barrier.await();
        } catch (Exception e) {
            e.printStackTrace();
        } } }

TestSort测试排序 

public class TestSort {
    private final int SIZE = 10;
    private int[] array = new int[SIZE];
    //创建长度为SIZE的随机数组
    @Before
    public void init() {
        for (int i = 0; i < SIZE; i++) {
            array[i] = (int) (Math.random() * 100 + 1);
        }
    }
    @Test
    public void testThreadSort() throws Exception {
        System.out.println("未排序之前:" + Arrays.toString(array));
        SortService sortService = new SortService(array);
        sortService.printSortedArray();
    } }