Java’s Fork/Join framework is an ExecutorService-based way to divide a large computation into smaller tasks, run them in a ForkJoinPool, and combine their results. Its work-stealing scheduler lets an idle worker take pending tasks from a busier worker. It is most useful for CPU-bound work that can be split into independent pieces; it is not a general speed boost for blocking I/O or every parallel program.
How Fork/Join works
A Fork/Join program follows divide-and-conquer: a task checks whether its input is small enough to handle directly. If it is, it computes the result sequentially. Otherwise, it splits the input, creates subtasks, and combines their results after they finish.
The ForkJoinPool runs tasks, while ForkJoinTask represents an individual unit of work. Fork/Join tasks are lighter than ordinary threads, so a small number of pool workers can execute many subtasks. The framework’s distinguishing scheduler uses work stealing: workers with no local work can take pending tasks from other workers’ queues. This helps balance uneven task trees, but it cannot parallelize work that is inherently serial.
For an overview of the framework and its place in Java, see Oracle’s Fork/Join tutorial.
Recommended Free Tools
Choose RecursiveTask or RecursiveAction
RecursiveTask for a returned value
Extend RecursiveTask<V> when each task produces a value that its parent needs to combine. A sum, for example, returns partial sums that parent tasks add together.
RecursiveAction for work without a returned value
Extend RecursiveAction when a task performs an operation rather than computing a result for its caller, such as transforming an array segment in place. Oracle’s Fork/Join technical article describes these tasks as executions that do not yield a return value.
Rank #2
Other task types
ForkJoinTask is the lower-level base abstraction. CountedCompleter is an option for workflows where completion of one action triggers further actions, rather than relying on a parent to synchronously collect child results. See the ForkJoinTask API for the task types and their documented behavior.
Implement the divide-and-conquer pattern
This example sums an inclusive integer range. It forks the left side, computes the right side directly on the current worker, then joins the left result. Computing one branch directly avoids needlessly leaving the current worker idle while both children are scheduled.
import java.util.concurrent.RecursiveTask;
class SumTask extends RecursiveTask<Long> {
private final long start;
private final long end;
private final long threshold;
SumTask(long start, long end, long threshold) {
this.start = start;
this.end = end;
this.threshold = threshold;
}
@Override
protected Long compute() {
if (end - start <= threshold) {
long sum = 0;
for (long n = start; n <= end; n++) {
sum += n;
}
return sum;
}
long middle = start + (end - start) / 2;
SumTask left = new SumTask(start, middle, threshold);
SumTask right = new SumTask(middle + 1, end, threshold);
left.fork();
long rightResult = right.compute();
long leftResult = left.join();
return leftResult + rightResult;
}
}Submit the root task to a pool to run it:
import java.util.concurrent.ForkJoinPool;
ForkJoinPool pool = new ForkJoinPool();
long result = pool.invoke(new SumTask(1, 1_000_000, 10_000));
pool.shutdown();The threshold here is only an example, not a recommended universal value. The right threshold depends on the cost of each unit of work, input size, machine, and JDK. Benchmark against a sequential implementation using the same input and environment before deciding that a parallel version is faster.
When Fork/Join is a good fit
Fork/Join is designed to work best when task dependencies form an acyclic directed acyclic graph (DAG), tasks are nested, each task has reasonable granularity, and tasks are independent in their use of memory and other resources. OpenJDK describes these as design conditions for the pool, not as guarantees of performance. See the OpenJDK ForkJoinPool source.
Rank #4
- Good candidate: a CPU-bound computation that can be recursively divided into substantial, mostly independent pieces.
- Potentially poor candidate: work dominated by blocking I/O, shared mutable state, or synchronization. Blocking tasks can occupy workers that might otherwise run useful tasks.
- Unsafe dependency pattern: joins that wait in a cycle. Keep dependencies acyclic so a task is not waiting, directly or indirectly, for work that cannot proceed until it completes.
Fork/Join task documentation advises minimizing blocking synchronization, avoiding blocking I/O in subdividable tasks, and preferring independent data access. Joins and cooperating synchronizers are part of normal task coordination, but excessive contention can reduce scalability.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Tune task size and evaluate performance
Each split and scheduled task has overhead. If tasks are too small, scheduling and queue management can cost more than the computation. If tasks are too large, the pool may not expose enough parallel work to keep available processors busy. Tune the sequential cutoff for the actual workload rather than copying a threshold from an unrelated example.
Free tools Windows power users keep installed
One-click scans. No signup required.
Best Value
Compare parallel and sequential versions with the same algorithmic work, input, JDK, hardware, and measurement method. A credible speedup claim needs those details; there is no universal threshold or percentage improvement for an unspecified program. Also check whether shared-state contention or serial portions limit the benefit even after task sizing is adjusted.
Fork/Join in everyday Java APIs
You can use the model directly with RecursiveTask and RecursiveAction, but some Java APIs apply Fork/Join techniques internally. Oracle’s Java tutorial identifies Arrays.parallelSort and parallel operations in Java streams as examples. It describes parallel sorting of large arrays as potentially faster on multiprocessor systems, not as a guaranteed improvement for every array or machine. The relevant Java SE 8 discussion is in the Oracle streams and parallelism tutorial.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
