java多线程如何排序

在 Java 中，“多线程如何排序”通常有两种理解：

1. 用多线程对一个大数组/集合进行排序（并行排序）
2. 多个线程各自产生数据，最后有序汇总（并发排序场景）

下面分别说明，并给出常见做法和示例代码。

一、直接用 JDK 自带的并行排序（最推荐）

1. 基本类型数组：Arrays.parallelSort

import java.util.Arrays;

public class ParallelSortDemo {
    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 1, 9, 2};
        Arrays.parallelSort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

• 内部使用 ForkJoinPool
• 数据量越大，优势越明显
• 适合：int[]、long[]、double[] 等

2. 对象数组 / List：parallelStream().sorted()

import java.util.*;
import java.util.stream.Collectors;

public class ParallelStreamSort {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(5, 3, 8, 1, 9, 2);

        List<Integer> sorted = list.parallelStream()
                                  .sorted()
                                  .collect(Collectors.toList());

        System.out.println(sorted);
    }
}

⚠ 注意：

• parallelStream 不一定总是更快
• 小数据量可能更慢（线程调度开销）

二、自己用多线程实现排序（学习/面试用）

思路（分治）

1. 把数组拆成多段
2. 每个线程排一段
3. 合并结果（归并）

示例：多线程归并排序

import java.util.*;
import java.util.concurrent.*;

public class MultiThreadSort {

    static class SortTask extends RecursiveAction {
        int[] arr;
        int left, right;

        SortTask(int[] arr, int left, int right) {
            this.arr = arr;
            this.left = left;
            this.right = right;
        }

        @Override
        protected void compute() {
            if (right - left <= 1000) {
                Arrays.sort(arr, left, right + 1);
            } else {
                int mid = (left + right) / 2;
                invokeAll(
                        new SortTask(arr, left, mid),
                        new SortTask(arr, mid + 1, right)
                );
                merge(arr, left, mid, right);
            }
        }

        void merge(int[] a, int l, int m, int r) {
            int[] temp = Arrays.copyOfRange(a, l, r + 1);
            int i = 0, j = m - l + 1, k = l;
            while (i <= m - l && j < temp.length) {
                if (temp[i] <= temp[j]) a[k++] = temp[i++];
                else a[k++] = temp[j++];
            }
            while (i <= m - l) a[k++] = temp[i++];
        }
    }

    public static void main(String[] args) {
        int[] arr = new Random().ints(100000).toArray();
        ForkJoinPool.commonPool().invoke(
                new SortTask(arr, 0, arr.length - 1)
        );
        System.out.println(Arrays.toString(Arrays.copyOf(arr, 20)));
    }
}

三、多线程“并发产生数据后排序”

如果是：

多个线程不断往集合里放数据，最后要整体有序

✅ 正确做法：

• 先用线程安全结构收集
• 最后统一排序

List<Integer> list = Collections.synchronizedList(new ArrayList<>());

// 多线程 add
// ...

List<Integer> sorted = list.stream().sorted().toList();

❌ 不建议：

• 边插入边排序（性能极差）
• 用 PriorityBlockingQueue 做大规模排序（只适合流式取最小/最大）

四、如何选择？

如果你有具体场景（比如：

• 超大文件排序
• 多线程日志按时间排序
• 面试题“手写多线程排序”

可以告诉我，我可以给你更针对性的方案。