Extremely Serious

Category: Java 7

Exploring Java’s Fork-Join Framework: Parallelism Made Efficient

Java's Fork-Join Framework, introduced in Java 7 as part of the java.util.concurrent package, offers a powerful mechanism for parallelizing and efficiently handling divide-and-conquer-style algorithms. At its core is the ForkJoinPool, a sophisticated executor service designed for managing parallel tasks.

Overview of Fork-Join Framework

The Fork-Join Framework is particularly well-suited for recursive and divide-and-conquer algorithms. It provides two main classes: RecursiveTask for tasks that return a result, and RecursiveAction for tasks that perform an action without returning a result.

ForkJoinPool and Parallelism

The ForkJoinPool manages a set of worker threads and facilitates the parallel execution of tasks. The default pool size is dynamically determined based on the available processors on the machine. This adaptive sizing allows for efficient resource utilization.

// Creating a ForkJoinPool with default parallelism
ForkJoinPool forkJoinPool = new ForkJoinPool();

Limiting the Size of the Pool

It is possible to limit the size of the ForkJoinPool by specifying the parallelism level during its creation. This can be useful to control resource usage and adapt the pool to specific requirements.

// Creating a ForkJoinPool with a limited parallelism level
int parallelismLevel = 4;
ForkJoinPool limitedPool = new ForkJoinPool(parallelismLevel);

Work-Stealing Strategy

The heart of the Fork-Join Framework's efficiency lies in its work-stealing strategy. Here's a breakdown of how it works:

  • Task Splitting: Tasks can recursively split into smaller subtasks during execution.
  • Deque Structure: Each worker thread has its own deque (double-ended queue) for storing tasks.
  • Stealing Tasks: When a worker thread's deque is empty, it steals tasks from other worker threads' deques, minimizing contention.
  • Load Balancing: The strategy ensures efficient load balancing by redistributing tasks among available threads.
  • Task Affinity: Threads tend to execute tasks they have recently created or stolen, optimizing cache usage.

Handling Blocking Situations

If all worker threads are blocked, for instance, due to tasks waiting on external resources, the pool can become stalled. In such cases, the efficiency of the Fork-Join Pool might be compromised. It's crucial to be mindful of blocking operations within tasks and consider alternative concurrency mechanisms if needed.

6. Managing the Pool's Lifecycle

Once a ForkJoinPool is created, it should be explicitly shut down when no longer needed to prevent resource leaks and ensure a clean application exit.

// Shutting down the ForkJoinPool

7. Sample Usage

Let's consider a simple example of calculating the sum of an array using a Fork-Join task:

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

public class SumTask extends RecursiveTask<Integer> {
    private final int[] data;
    private final int start;
    private final int end;

    public SumTask(int[] data, int start, int end) {
        this.data = data;
        this.start = start;
        this.end = end;

    protected Integer compute() {
        if (end - start <= 10) {
            // Solve the problem sequentially
            int sum = 0;
            for (int i = start; i < end; i++) {
                sum += data[i];
            return sum;
        } else {
            // Split the task into subtasks
            int mid = (start + end) / 2;
            SumTask leftTask = new SumTask(data, start, mid);
            SumTask rightTask = new SumTask(data, mid, end);

            // Fork the subtasks

            // Join the results
            int leftResult = leftTask.join();
            int rightResult = rightTask.join();

            // Combine the results
            return leftResult + rightResult;

    public static void main(String[] args) {
        int[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        int result = forkJoinPool.invoke(new SumTask(data, 0, data.length));
        System.out.println("Result: " + result);

        // Don't forget to shut down the pool when it's no longer needed

In this example, we use a ForkJoinPool to calculate the sum of an array efficiently by dividing the task into subtasks and utilizing the work-stealing strategy.

Using Scanner to Read a Text File

Reading a text file using java.util.Scanner in Java.

StringBuilder text = new StringBuilder();
try(Scanner scanner = new Scanner(new BufferedReader(new FileReader("<FILENAME>")))) {
    while(scanner.hasNext()) {
} catch (FileNotFoundException e) {


FILENAME The text file to read.