Yichun Zhao's blog

Fork-Join, Implement a List of Tasks Concurrently

Yichun Zhao's photo
Yichun Zhao
·

2 min read

The Fork/Join framework in Java is well-suited for scenarios where you have a list of tasks that can be processed concurrently. Introduced in Java 7, this framework is designed to help divide and conquer tasks, making it particularly effective for recursive and parallel algorithms.

The Fork/Join framework mainly uses two classes: ForkJoinPool and ForkJoinTask (with its common subclasses RecursiveAction for tasks that don't return a result and RecursiveTask for tasks that do return a result).

Concept:

  • Fork: The process of splitting a big task into smaller tasks, which can be executed concurrently.
  • Join: The process of waiting for the completion of all the subtasks and then combining the results of these subtasks.

Implementing Fork/Join with a List of Tasks:

Assuming you have a list of tasks and each task is independent and can be processed in parallel, you can use RecursiveAction or RecursiveTask depending on whether your tasks return a result.

Here's a simplified example using RecursiveAction:

import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class TaskProcessor extends RecursiveAction {
    private List<MyTask> tasks;

    public TaskProcessor(List<MyTask> tasks) {
        this.tasks = tasks;
    }

    @Override
    protected void compute() {
        if (tasks.size() <= THRESHOLD) { // base case
            processDirectly(tasks);
        } else {
            // Splitting task into two parts
            int mid = tasks.size() / 2;
            invokeAll(new TaskProcessor(tasks.subList(0, mid)),
                      new TaskProcessor(tasks.subList(mid, tasks.size())));
        }
    }

    private void processDirectly(List<MyTask> tasks) {
        for (MyTask task : tasks) {
            task.process(); // Processing the task
        }
    }
}

Usage:

To use the TaskProcessor, you need to create an instance of ForkJoinPool and then submit your task processor to this pool:

public class Main {
    public static void main(String[] args) {
        ForkJoinPool pool = new ForkJoinPool();
        TaskProcessor processor = new TaskProcessor(myListOfTasks);
        pool.invoke(processor);
    }
}

class MyTask {
    void process() {
        // Task processing logic
    }
}

Points to Note:

  1. Task Granularity: Choose an appropriate threshold for splitting tasks. Too small, and you'll have overhead from task management; too large, and you won't utilize concurrency effectively.

  2. Thread Safety: Ensure that your task processing logic is thread-safe.

  3. Task Independence: Fork/Join works best when tasks are independent and can be processed in parallel without needing to wait for other tasks to complete.

  4. Overhead: Be aware of the overhead that comes with managing the Fork/Join tasks. For small or simple tasks, the traditional executor services might be more efficient.

The Fork/Join framework is a powerful tool for parallel processing in Java, but it's essential to use it in the right context and with an understanding of its overhead and complexity.

Forkjoin