Java Fork/Join 框架详解

Java Fork/Join 框架详解

Fork/Join 框架是 Java 7 引入的一个并行编程框架，专门设计用来高效地实现分治算法（Divide-and-Conquer）。它通过工作窃取（Work-Stealing）算法来最大化多核处理器的利用率。

---

一、核心概念

1. 基本组成

• ForkJoinPool：特殊的线程池，管理工作线程
• ForkJoinTask：表示任务的抽象类，有两个重要子类：
  • RecursiveAction：用于没有返回结果的任务
  • RecursiveTask：用于有返回结果的任务

2. 工作窃取算法

• 每个工作线程维护自己的任务队列（双端队列）
• 当自己的任务队列为空时，可以从其他线程的队列尾部"窃取"任务
• 这种设计减少了线程竞争，提高了CPU利用率

---

二、框架使用模式

1. 基本使用步骤

// 1. 创建任务
class MyTask extends RecursiveAction {
    protected void compute() {
        // 任务逻辑
    }
}

// 2. 创建线程池
ForkJoinPool pool = new ForkJoinPool();

// 3. 提交任务
pool.invoke(new MyTask());

2. 典型分治模式

if (问题足够小) {
    直接解决问题;
} else {
    将问题分解为子问题;
    递归调用子问题;
    合并子问题的结果;
}

---

三、关键API详解

1. ForkJoinPool

• 构造方法：

  • ForkJoinPool()：使用默认并行级别（Runtime.getRuntime().availableProcessors()）
  • ForkJoinPool(int parallelism)：指定并行级别

• 重要方法：

  • invoke(ForkJoinTask task)：执行任务并等待结果
  • execute(ForkJoinTask task)：异步执行任务
  • submit(ForkJoinTask task)：提交任务并返回Future

2. ForkJoinTask

• 关键方法：
  • fork()：异步执行子任务
  • join()：获取子任务结果
  • invoke()：开始执行任务并等待结果
  • invokeAll(ForkJoinTask... tasks)：执行多个任务

---

四、代码示例

示例1：计算1到n的和（RecursiveTask）

import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;

public class SumTask extends RecursiveTask<Long> {
    private static final int THRESHOLD = 10_000;
    private final int start;
    private final int end;

    public SumTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if (end - start <= THRESHOLD) {
            long sum = 0;
            for (int i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        } else {
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(start, mid);
            SumTask rightTask = new SumTask(mid + 1, end);
            
            leftTask.fork(); // 异步执行左子任务
            long rightResult = rightTask.compute(); // 同步执行右子任务
            long leftResult = leftTask.join(); // 获取左子任务结果
            
            return leftResult + rightResult;
        }
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        long result = pool.invoke(new SumTask(1, 1_000_000));
        System.out.println("Sum: " + result);
        pool.shutdown();
    }
}

示例2：遍历目录统计文件（RecursiveAction）

import java.io.File;
import java.util.concurrent.RecursiveAction;

public class FileSearchTask extends RecursiveAction {
    private final File directory;

    public FileSearchTask(File directory) {
        this.directory = directory;
    }

    @Override
    protected void compute() {
        File[] files = directory.listFiles();
        if (files != null) {
            for (File file : files) {
                if (file.isDirectory()) {
                    // 如果是目录，创建子任务
                    FileSearchTask task = new FileSearchTask(file);
                    task.fork();
                } else {
                    // 处理文件
                    System.out.println(file.getAbsolutePath());
                }
            }
            
            // 等待所有子任务完成
            invokeAll();
        }
    }

    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        pool.invoke(new FileSearchTask(new File(".")));
        pool.shutdown();
    }
}

---

五、最佳实践

1. 合理设置阈值：

   • 任务分解到足够小以避免过多任务开销
   • 但也不能太大以充分利用并行性

2. 避免阻塞操作：

   • Fork/Join框架不适合I/O密集型任务
   • 设计为CPU密集型计算

3. 任务平衡：

   • 尽量使子任务工作量相近
   • 避免某些任务特别大而其他任务很小

4. 异常处理：

   • 使用ForkJoinTask的getException()方法检查异常

5. 性能监控：

   • 使用ForkJoinPool的getStealCount()等方法监控性能

---

六、与普通线程池比较

特性	ForkJoinPool	普通线程池
设计目标	分治算法	通用任务执行
任务队列	每个线程有自己的队列	共享任务队列
工作方式	工作窃取	任务拉取
适合任务类型	计算密集型	I/O密集型或混合型
任务分解	自动分解	需要手动分解

Fork/Join框架特别适合可以递归分解的问题，如排序、搜索、数学计算等。对于其他类型的并行任务，传统的线程池可能更合适。