Fork/Join 是一种并行计算模式,主要用于将任务分解为更小的子任务(Fork),递归地解决这些子任务,然后将结果合并(Join)以获得最终结果。这种模式非常适合于可以并行处理的任务,特别是那些可以分解为多个独立子问题的任务。
### Fork/Join 框架的关键概念:
1. **任务(Task)**:表示可以执行的工作单元。在 Java 中,可以通过实现 `Callable` 接口来创建任务。
2. **工作窃取(Work Stealing)**:这是一种算法,工作线程可以从其他线程的队列中窃取任务来执行,以此来平衡负载和提高资源利用率。
3. **Fork**:将一个复杂的任务分解为两个或多个更小的任务。
4. **Join**:等待一个或多个任务完成,并合并它们的结果。
5. **递归**:Fork/Join 模式通常与递归结合使用,即每个子任务可能进一步分解为更小的子任务。
6. **线程池**:Fork/Join 模式通常与线程池一起使用,以便有效地管理线程资源。
### Java 中的 Fork/Join 框架:
Java 7 引入了 `java.util.concurrent` 包中的 `ForkJoinPool` 类,它是专门为执行 Fork/Join 任务设计的线程池。使用 `ForkJoinPool` 可以简化并行任务的执行和管理。
以下是使用 Java Fork/Join 框架的基本步骤:
1. **创建 ForkJoinPool**:根据需要创建一个 `ForkJoinPool` 实例。
2. **定义任务**:实现 `Callable` 接口或继承 `RecursiveTask` 或 `RecursiveAction` 类来定义任务。`RecursiveTask` 有返回值,而 `RecursiveAction` 没有返回值。
3. **分解任务**:在任务的 `call` 方法中实现任务的分解逻辑。
4. **执行任务**:使用 `ForkJoinPool` 的 `invoke` 或 `execute` 方法来执行任务。
5. **合并结果**:对于 `RecursiveTask`,可以在任务完成后获取结果。
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
public class ForkJoinExample extends RecursiveTask<Integer> {
private int start;
private int end;
private static final int THRESHOLD = 10;
public ForkJoinExample(int start, int end) {
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
int result = 0;
if (end - start <= THRESHOLD) {
// 基本情况,直接计算
for (int i = start; i <= end; i++) {
result += i;
}
} else {
// 分解任务
int middle = (start + end) / 2;
ForkJoinExample subTask1 = new ForkJoinExample(start, middle);
ForkJoinExample subTask2 = new ForkJoinExample(middle + 1, end);
// 执行子任务
subTask1.fork();
subTask2.fork();
// 合并结果
result = subTask1.join() + subTask2.join();
}
return result;
}
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
ForkJoinExample task = new ForkJoinExample(1, 100);
pool.invoke(task);
System.out.println("Result: " + task.join());
}
}
在这个示例中,我们创建了一个计算 1 到 100 整数之和的任务。任务被分解为更小的子任务,直到达到阈值 `THRESHOLD`,然后递归地计算并合并结果。`ForkJoinPool` 负责调度和执行这些任务。
Fork/Join 模式适用于可以分解为多个子任务的场景,如数值计算、大数据处理等。它通过工作窃取和递归分解提高了并行计算的效率。
利用Fork/Join遍历指定文件夹下的txt文件
package com;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.RecursiveAction;
public class FileForkJoin extends RecursiveAction {
private File file;
public FileForkJoin(File file) {
this.file = file;
}
@Override
protected void compute() {
List<FileForkJoin> fileForkJoins= new ArrayList<>();
if(file.exists()){
if (file.isDirectory()){
File[] files = file.listFiles();
if(files != null){
for (File file1 : files) {
fileForkJoins.add(new FileForkJoin(file1));
}
}
}else if(file.isFile() && file.getName().endsWith(".txt")){
System.out.println(file.getAbsolutePath());
}
}
if(!fileForkJoins.isEmpty()){
//invokeAll 方法是 ForkJoinTask 的一个静态方法,它允许你启动一组 ForkJoinTask 任务并等待它们全部完成,然后返回包含所有结果的数组。
for (FileForkJoin fileForkJoin : invokeAll(fileForkJoins)) {
fileForkJoin.join();
}
}
}
}
public class TestFileForkJoin {
public static void main(String[] args) {
ForkJoinPool pool = new ForkJoinPool();
FileForkJoin fileForkJoin = new FileForkJoin(new File("F://"));
//异步任务
pool.submit(fileForkJoin);
fileForkJoin.join();
System.out.println("end");
}
}