Understanding ForkJoinPool: Divide‑and‑Conquer, Implementation Details, and Performance Evaluation in Java

In this tutorial we explore Java's ForkJoinPool , a thread‑pool implementation of the Fork/Join model introduced in Java 7 and widely used in Java 8 for parallel streams and CompletableFuture.

1. Divide‑and‑Conquer and the Fork/Join Model

The Fork/Join approach applies the classic divide‑and‑conquer strategy: a large problem of size N is recursively split into K smaller independent sub‑problems, each solved separately, and the partial results are merged to obtain the final answer.

Decompose : split the problem into smaller sub‑problems.

Solve : compute each sub‑problem directly when it becomes sufficiently small.

Combine : merge the sub‑results to form the overall solution.

The following pseudo‑code illustrates the recursive process:

solve(problem):
    if problem is small enough:
        // execute directly
        return sequentialResult
    else:
        for part in subdivide(problem):
            fork subtask to solve(part)
        // combine results
        return combinedResults

2. Fork/Join Application Example

We implement a TheKingRecursiveSumTask that extends RecursiveTask<Long> to compute the sum of a range of integers. The task defines sumBegin , sumEnd , and a threshold for splitting.

public class TheKingRecursiveSumTask extends RecursiveTask
{
    private static final AtomicInteger taskCount = new AtomicInteger();
    private final int sumBegin;
    private final int sumEnd;
    private final int threshold;

    public TheKingRecursiveSumTask(int sumBegin, int sumEnd, int threshold) {
        this.sumBegin = sumBegin;
        this.sumEnd = sumEnd;
        this.threshold = threshold;
    }

    @Override
    protected Long compute() {
        if ((sumEnd - sumBegin) > threshold) {
            TheKingRecursiveSumTask subTask1 = new TheKingRecursiveSumTask(sumBegin, (sumBegin + sumEnd) / 2, threshold);
            TheKingRecursiveSumTask subTask2 = new TheKingRecursiveSumTask((sumBegin + sumEnd) / 2, sumEnd, threshold);
            subTask1.fork();
            subTask2.fork();
            taskCount.incrementAndGet();
            return subTask1.join() + subTask2.join();
        }
        long result = 0L;
        for (int i = sumBegin; i < sumEnd; i++) {
            result += i;
        }
        return result;
    }

    public static AtomicInteger getTaskCount() {
        return taskCount;
    }
}

Running the task on the range 0 ~ 10,000,000 with a threshold of 100 and a parallelism level of 16 yields the following output:

======
ForkJoin任务拆分：131071
ForkJoin计算结果：49999995000000
ForkJoin计算耗时：207
======
单线程计算结果：49999995000000
单线程计算耗时：40

Surprisingly, the Fork/Join version is slower because the task granularity is too fine; many tiny subtasks incur overhead.

3. ForkJoinPool Design and Source‑Code Analysis

ForkJoinPool implements Executor and ExecutorService similar to ThreadPoolExecutor . Its core parameters are:

parallelism : number of worker threads (defaults to the number of available processors).

ForkJoinWorkerThreadFactory : factory for creating worker threads.

UncaughtExceptionHandler : handler for uncaught task exceptions.

asyncMode : determines whether the work queue uses FIFO (true) or LIFO (false) ordering.

Three construction styles are provided:

// 1. Default constructor (no arguments)
public ForkJoinPool() { ... }

// 2. Specify parallelism only
public ForkJoinPool(int parallelism) { ... }

// 3. Full custom constructor
public ForkJoinPool(int parallelism, ForkJoinWorkerThreadFactory factory,
                    UncaughtExceptionHandler handler, boolean asyncMode) { ... }

Task Submission Methods

ForkJoinPool supports three families of submission APIs:

From non‑fork/join thread

From fork/join thread

Asynchronous execution

execute(ForkJoinTask)

ForkJoinTask.fork()

Synchronous execution (wait for result)

invoke(ForkJoinTask)

ForkJoinTask.invoke()

Submit and obtain a Future

submit(ForkJoinTask)

ForkJoinTask.fork() (ForkJoinTask is a Future)

Key methods:

public
T invoke(ForkJoinTask
task) { ... }
public void execute(ForkJoinTask
task) { ... }
public
ForkJoinTask
submit(ForkJoinTask
task) { ... }

ForkJoinTask Types

Two main subclasses of ForkJoinTask are used:

RecursiveAction : tasks that do not return a result (e.g., parallel sorting).

RecursiveTask<V> : tasks that return a value (e.g., sum, Fibonacci).

Example of a RecursiveAction for parallel sort:

static class SortTask extends RecursiveAction {
    final long[] array; final int lo, hi;
    SortTask(long[] array, int lo, int hi) { this.array = array; this.lo = lo; this.hi = hi; }
    protected void compute() {
        if (hi - lo < THRESHOLD) Arrays.sort(array, lo, hi);
        else {
            int mid = (lo + hi) >>> 1;
            invokeAll(new SortTask(array, lo, mid), new SortTask(array, mid, hi));
            merge(lo, mid, hi);
        }
    }
    // merge implementation omitted for brevity
}

fork() and join()

fork() pushes the task onto the current worker’s deque (or the common pool if called from a non‑worker thread). join() blocks until the task completes and returns its result.

public final ForkJoinTask
fork() { ... }
public final V join() { ... }

Work‑Stealing Queues

Each worker thread owns a double‑ended queue. Workers pop tasks from the head (LIFO) for cache locality, while idle workers steal from the tail (FIFO) of other workers to reduce contention.

4. Caution with ForkJoinPool.commonPool

The static commonPool is a shared pool used by parallel streams and CompletableFuture. Because it is shared across the entire JVM, submitting blocking tasks to it can starve other computations, potentially degrading the whole application.

5. Performance Evaluation

Simple experiments on macOS with JDK 8 show that a very low split threshold (e.g., 100) leads to excessive task creation and makes ForkJoinPool slower than a single‑thread loop. Raising the threshold to 100 000 reduces the number of splits dramatically and yields a clear speed‑up (≈3× faster).

Key factors influencing performance are:

Total number of tasks.

Cost of each individual task.

Parallelism level (number of worker threads).

Before using Fork/Join in production, benchmark these parameters for your specific workload.

Conclusion

ForkJoinPool provides a powerful framework for parallelizing pure computational workloads using divide‑and‑conquer and work‑stealing. It excels when tasks are CPU‑bound, stateless, and have sufficient granularity. For blocking or I/O‑heavy tasks, consider a regular thread pool or a dedicated ForkJoinPool instance rather than the common pool.