# concurrentSort

**Repository Path**: lyfxinsui/concurrentSort

## Basic Information

- **Project Name**: concurrentSort
- **Description**: 该项目是一个基于Fork/Join 框架实现的一个并行排序框架,支持实现Comparable,Comparator数组,列表(List)的并行排序,代码通俗易懂,是一份学习Fork/Join框架不错的资料。
- **Primary Language**: Java
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 13
- **Forks**: 2
- **Created**: 2015-10-05
- **Last Updated**: 2026-10-12

## Categories & Tags

**Categories**: utils

**Tags**: None

## README

# concurrentSort

一个基于 Java Fork/Join 框架实现的高性能并发排序库。

## 项目简介

concurrentSort 是一个支持数组和列表并发排序的 Java 库，采用 Java 7 引入的 Fork/Join 框架实现多线程并行排序。通过将排序任务递归分解为子任务并行执行，可以充分利用多核 CPU 的计算能力，显著提升大数据集的排序效率。

## 特性

- **并发排序**：利用 Fork/Join 框架实现高效的并行排序
- **多种数据类型支持**：支持数组（Array）和列表（List）两种数据结构的排序
- **灵活的比较方式**：同时支持 `Comparable` 接口和 `Comparator` 自定义比较器
- **可配置线程数**：支持自定义线程负载数量，满足不同性能需求
- **易于使用**：提供简洁的静态方法入口，快速实现并发排序

## 快速开始

### Maven 依赖

```xml
<dependency>
    <groupId>concurrentSort</groupId>
    <artifactId>concurrentSort</artifactId>
    <version>1.0</version>
</dependency>
```

### 基本用法

#### 数组排序（使用 Comparable）

```java
import com.org.sort.ConcurrentSorts;
import java.util.concurrent.ForkJoinPool;

Integer[] array = {5, 3, 8, 1, 9, 2, 7, 4, 6};
ForkJoinPool pool = ForkJoinPool.commonPool();
Integer[] sorted = ConcurrentSorts.sort(pool, array);
```

#### 数组排序（使用 Comparator）

```java
import com.org.sort.ConcurrentSorts;
import java.util.concurrent.ForkJoinPool;

String[] array = {"banana", "apple", "cherry", "date"};
ForkJoinPool pool = ForkJoinPool.commonPool();
String[] sorted = ConcurrentSorts.sort(pool, array, String::compareTo);
```

#### 列表排序

```java
import com.org.sort.ConcurrentSorts;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ForkJoinPool;

List<Integer> list = Arrays.asList(5, 3, 8, 1, 9, 2);
ForkJoinPool pool = ForkJoinPool.commonPool();
List<Integer> sorted = ConcurrentSorts.sort(pool, list);
```

### 指定线程数

```java
// 指定使用 4 个线程进行排序
Integer[] sorted = ConcurrentSorts.sort(pool, array, 4);
```

## API 参考

### ConcurrentSorts 静态方法

| 方法 | 描述 |
|------|------|
| `sort(ForkJoinPool pool, T[] array)` | 使用 Comparable 对数组进行并发排序 |
| `sort(ForkJoinPool pool, T[] array, int threadloads)` | 指定线程数对数组进行并发排序 |
| `sort(ForkJoinPool pool, T[] array, Comparator<? super T> comparator)` | 使用 Comparator 对数组进行并发排序 |
| `sort(ForkJoinPool pool, T[] array, Comparator<? super T> comparator, int threadloads)` | 指定线程数并使用 Comparator 对数组排序 |
| `sort(ForkJoinPool pool, List<T> list)` | 使用 Comparable 对列表进行并发排序 |
| `sort(ForkJoinPool pool, List<T> list, int threadloads)` | 指定线程数对列表进行并发排序 |
| `sort(ForkJoinPool pool, List<T> list, Comparator<? super T> comparator)` | 使用 Comparator 对列表进行并发排序 |
| `sort(ForkJoinPool pool, List<T> list, int threadloads, Comparator<? super T> comparator)` | 指定线程数并使用 Comparator 对列表排序 |

## 核心类说明

- **ConcurrentSort**：排序核心抽象类，继承 `RecursiveAction`，实现快速排序的并行化
- **AbConcurrentArrySort**：数组排序抽象基类
- **AbConcurrentListSort**：列表排序抽象基类
- **ArrayConcurrentSortComparable**：实现基于 Comparable 的数组并发排序
- **ArrayConcurrentSortComparator**：实现基于 Comparator 的数组并发排序
- **ListConcurrentSortComparable**：实现基于 Comparable 的列表并发排序
- **ListConcurrentSortComparator**：实现基于 Comparator 的列表并发排序

## 运行测试

```bash
mvn test
```

## 性能说明

并发排序的性能提升取决于：
- CPU 核心数（核心数越多，性能提升越明显）
- 待排序数据量（数据量越大，并发优势越明显）
- 线程负载配置

对于小数据量，单线程排序可能更快，因为并发带来的线程创建和任务调度开销可能会抵消并行带来的收益。

## 许可证

MIT License