使用 forkjoinpool 分治任务的核心做法是继承 forkjointask(通常用 recursiveaction 处理无返回值或 recursivetask<v></v> 处理有返回值),重写 compute() 方法,在方法内判断任务规模是否小于阈值,若大于阈值则拆分为子任务并调用 fork() 提交,再调用 join() 等待结果合并;若小于阈值则直接执行。这样能利用工作窃取算法自动平衡线程负载。

ForkJoinPool 的默认并行度如何确定
默认情况下,ForkJoinPool 的并行度等于当前机器的可用处理器数量,即 Runtime.getRuntime().availableProcessors()。这意味着如果你不指定参数,它会自动创建与 CPU 核心数相同的线程数来执行任务。这个设计是为了最大化 CPU 利用率,避免过多的上下文切换开销。你可以通过构造函数传入自定义的并行度,或者使用静态工厂方法 ForkJoinPool.commonPool() 获取共享池,但要注意共享池的任务可能会与其他应用逻辑竞争资源。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
public class Main {
public static void main(String[] args) {
int[] data = new int[1000];
for (int i = 0; i < data.length; i++) {
data[i] = i;
}
// 使用默认并行度的 ForkJoinPool
ForkJoinPool pool = new ForkJoinPool();
System.out.println("Parallelism: " + pool.getParallelism());
pool.invoke(new SumTask(data, 0, data.length));
pool.shutdown();
}
}
class SumTask extends RecursiveAction {
private final int[] data;
private final int start;
private final int end;
private static final int THRESHOLD = 100;
public SumTask(int[] data, int start, int end) {
this.data = data;
this.start = start;
this.end = end;
}
@Override
protected void compute() {
if (end - start <= THRESHOLD) {
// 直接计算
long sum = 0;
for (int i = start; i < end; i++) {
sum += data[i];
}
System.out.println("Thread: " + Thread.currentThread().getName() + " computed range [" + start + ", " + end + "]");
} else {
// 拆分任务
int mid = (start + end) / 2;
SumTask left = new SumTask(data, start, mid);
SumTask right = new SumTask(data, mid, end);
left.fork();
right.fork();
}
}
}运行上述代码,你会看到控制台输出多个线程处理的区间,且并行度默认为你的 CPU 核心数。例如在 8 核机器上,并行度通常为 8。每个子任务在达到阈值时由当前线程直接执行,否则继续拆分并由工作窃取机制调度。
立即学习“Java免费学习笔记(深入)”;
如何手动控制 ForkJoinPool 的并行度
要手动控制并行度,需要在实例化 ForkJoinPool 时通过构造函数传入 parallelism 参数。这适用于你需要限制并发资源以保护系统稳定性,或者在特定场景下优化吞吐量的情况。例如,你可以设置并行度为 4,即使机器有 16 个核心,也只会使用 4 个线程进行分治计算。此外,还可以使用 ForkJoinPool 的其他配置选项,如队列容量和异常处理策略,但并行度是最关键的参数。注意,修改并行度不会影响已提交的任务,只影响后续新任务的调度。

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class MainWithCustomPool {
public static void main(String[] args) {
int[] data = new int[1000];
for (int i = 0; i < data.length; i++) {
data[i] = i;
}
// 手动设置并行度为 4
int customParallelism = 4;
ForkJoinPool pool = new ForkJoinPool(customParallelism);
System.out.println("Custom Parallelism: " + pool.getParallelism());
Integer result = pool.invoke(new MaxValueTask(data, 0, data.length));
System.out.println("Max Value: " + result);
pool.shutdown();
}
}
class MaxValueTask extends RecursiveTask<Integer> {
private final int[] data;
private final int start;
private final int end;
private static final int THRESHOLD = 100;
public MaxValueTask(int[] data, int start, int end) {
this.data = data;
this.start = start;
this.end = end;
}
@Override
protected Integer compute() {
if (end - start <= THRESHOLD) {
int max = Integer.MIN_VALUE;
for (int i = start; i < end; i++) {
if (data[i] > max) {
max = data[i];
}
}
return max;
} else {
int mid = (start + end) / 2;
MaxValueTask left = new MaxValueTask(data, start, mid);
MaxValueTask right = new MaxValueTask(data, mid, end);
left.fork();
Integer rightResult = right.compute(); // 直接计算右半部分,左半部分由 fork 调度
Integer leftResult = left.join(); // 等待左半部分结果
return Math.max(leftResult, rightResult);
}
}
}运行此代码,你将观察到并行度被限制为 4,且任务分配遵循分治逻辑。通过比较不同并行度下的执行时间,可以验证资源限制对性能的影响。在实际应用中,建议根据任务类型和数据规模调整并行度,以达到最佳效果。
当子任务数量超过阈值时会发生什么
当子任务数量超过阈值时,ForkJoinPool 会持续递归拆分任务,直到每个子任务的规模小于预设的阈值。这个过程是动态的,每个线程在执行完自己的任务后,会尝试从其他线程的任务队列中“窃取”任务,从而平衡负载。如果所有子任务都已完成,线程将进入空闲状态,等待新任务或终止。这种机制确保了在高并发场景下,CPU 资源得到充分利用,同时避免了任务堆积导致的内存溢出或响应延迟。开发者只需关注阈值的设定,无需手动管理线程生命周期。


















