Difference Between Fork/Join Framework and ExecutorService in Java

In Java, the Fork/Join framework is majorly utilized for providing features and functionalities related to parallel processing and programming and this is carried out by dividing or breaking down an operation into smaller operations or instructions and they are processed with the help of available cores of CPU.

Similarly, ExecutorService in Java can be defined as an interface that is responsible for providing replacements regarding management and controlling of threads. The java.util.concurrent package is responsible for storing the ExecutorService interface in Java. The java.util.concurrent package was launched in Java 5.

Fork/Join Framework in Java

The Fork/Join framework of Java is mainly utilized for providing features and functionalities related to execution of task framework along with maximum performance. The parallel computing engine is mainly utilized for many high-level frameworks. Parallel programming is supported by the fork/join framework which can be useful in resolving problems using the divide and conquer technique. The problems can be resolved using the divide and conquer technique in the below-mentioned way:

A task will be divided or split into various sub-tasks.
All the sub-tasks will be solved in a parallel manner.
1. Various cores can be used for running individual sub-tasks in a parallel manner.
2. A single core can run or execute various sub-tasks concurrently in different threads.
Waiting state till all the sub-tasks are completely executed.
The results generated will be merged or grouped together.

Let's understand in detail about the features and functionalities of Fork/Join framework in Java with the help of a Java example program.

Filename: ForkAndJoin.java

// Java program for demonstrating the features and functionalities of Fork and Join Framework.
import java.io.*;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
class FindTask extends RecursiveTask<Integer> {
// Variables which are Non-static or instance.
int Arr[];
int first, last;
int target_Element;
// Initialization of Non static variables through constructor.
public FindTask(int Arr[], int first, int last,int target_Element)
{
// This Keyword is utilized for refering to the same instance of the object.
this.Arr = Arr;
this.first = first;
this.last = last;
this.target_Element = target_Element;
}
protected Integer compute()
{
// The Result is calculated and returned.
return Find_Process();
}
// Method that returns the count of a target element required.-
private Integer Find_Process()
{
// count variable is initialized with 0 value.
int cnt = 0;
for (int i = first; i <= last; i++) {
// Condition when target element is available in the Array of integers.
if (Arr[i] == target_Element) {
//The count value gets incremented.
cnt++;
}
}
// Returns the count value calculated of the target value provided.
return cnt;
}
}
public class ForkAndJoin{
public static void main(String args[])
{
// Declaring and initializing the integer array with random values.
int Arr[] = { 1 ,2 , 3 , 4 , 5, 5, 6 , 7, 8, 12, 11, 11, 1, 1, 1, 1, 2, 3, 8, 9};
// Target element whose count must be calculated.
int target_Element = 1;
// The First and Last variables being declared and initialized.
int first = 0;
int last = Arr.length - 1;
// The Object of ForkJoinPool is being created.
ForkJoinPool fork_join_pool = ForkJoinPool.commonPool();
// Object creation of above-mentioned class.
FindTask ans = new FindTask(Arr, first, last, target_Element);
int answer = fork_join_pool.invoke(ans);
// Calculates and displays the occurence of the target element, if not available displays the message.
System.out.println("The occurence of the Target element " +target_Element + " is " + answer + " times ");
}
}

Output:

ExecutorService in Java

In Java, the ExecutorService is majorly utilized for managing and controlling the order and execution of all the asynchronous tasks which are sometimes referred to as Runnable and Callable interfaces instances. The tasks can be submitted to an ExecutorService instead of dealing with threads directly. The tasks submitted to the ExecutorService will be taking care and managed by it regarding threads.

Let us understand in detail about the ExecutorService in Java with the help of a Java example program.

Filename: ExecutorServiceExample.java

// Java program for demonstration of features and functionalities of ExecutorService.
import java.io.*;
import java.util.Date;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
// This class extends the Runnable interface.
class Process implements Runnable {
// Non static or Instance variable of the above-mentioned class.
int I;
// Constructor of the above-mentioned class.
public Process(int I)
{
// Initialization of the non static or instance variable.
this.I = I;
}
public void run()
{
// Displaying the Counter.
System.out.println(I + " ");
// Using the block keyword for checking any exceptions.
try {
// The thread will be made to sleep for 1 second with the help of sleep() method.
Thread.sleep(1000);
}
// Using the catch block for catching the exceptions.
catch (InterruptedException e) {

// Displaying the line of error or exception and the message with it.
e.printStackTrace();
}
}
}
public class ExecutorServiceExample {
public static void main(String[] args)
{
// A fixed size thread pool gets created by creating object of the ExecutorServiceExample class.
ExecutorService ob1 = Executors.newFixedThreadPool(5);
// Displays the current time before execution.
System.out.println(new Date());
for (int I = 0; I < 25; I++) {
// This statement gets executed in the future.
ob1.execute(new Process(I));
}
//The executor get shut down so that the main task is considered to be completed.
ob1.shutdown();
// Displays the time after completion of task.
System.out.println(new Date());
}
}

Output:

Let's understand about the features and functionalities of both Fork/Join framework and ExecutorService in Java with the help of another example program.

Example 2:

Filename: ForkJoinExecutorService.java

// Java program for demonstrating the implementation of Fork and Join framework and ExecutorService in Java.
import java.util.concurrent.RecursiveTask;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Callable;
import java.util.ArrayList;
import java.util.List;
class AddTask extends RecursiveTask<Long> {
    private static final int threshold = 5; // Threshold for splitting the task
    private int[] arr;
    private int first;
    private int last;
    public AddTask(int[] arr, int first, int last) {
        this.arr = arr;
        this.first = first;
        this.last = last;
    }
    @Override
    protected Long compute() {
        if ((last - first) <= threshold) {
            return compute_InOrder();
        } else {
            int mid = first + (last - first) / 2;
            AddTask left_task = new AddTask(arr, first, mid);
            AddTask right_task = new AddTask(arr, mid, last);
            left_task.fork(); // Fork the left task
            long rightResult = right_task.compute(); // Compute the right task immediately
            long leftResult = left_task.join(); // Join the result of the left task
            return leftResult + rightResult;
        }
    }
    private long compute_InOrder() {
        long sum = 0;
        for (int i = first; i < last; i++) {
            sum += arr[i];
        }
        return sum;
    }
}
public class ForkJoinExecutorService {
    public static void main(String[] args) {
        int[] arr = {15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
        // Utilizing Fork/Join framework. 
        ForkJoinPool Fork_Join_Pool = ForkJoinPool.commonPool();
        long forkJoinResult = Fork_Join_Pool.invoke(new AddTask(arr, 0, arr.length));
        System.out.println("Result Obtained By Fork/Join Framework: " + forkJoinResult);
        // Utlizing ExecutorService
        ExecutorService executor_Service = Executors.newFixedThreadPool(4);
        List<Callable<Long>> main_tasks = new ArrayList<>();
        int chunk_size = arr.length / 4; // Split the arr into 4 chunks
        for (int i = 0; i < 4; i++) {
            int first = i * chunk_size;
            int last = (i == 3) ? arr.length : (i + 1) * chunk_size;
            main_tasks.add(() -> {
                long sum = 0;
                for (int j = first; j < last; j++) {
                    sum += arr[j];
                }
                return sum;
            });
        }
        try {
            long executorServiceResult = executor_Service.invokeAll(main_tasks)
                    .stream()
                    .mapToLong(future -> {
                        try {
                            return future.get();
                        } catch (InterruptedException | ExecutionException e) {
                            throw new RuntimeException(e);
                        }
                    })
                    .sum();
            System.out.println("Result Obtained By ExecutorService:  " + executorServiceResult);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            executor_Service.shutdown();
        }
    }
}

Output:

Result Obtained By Fork/Join Framework: 120
Result Obtained By ExecutorService:  120

Fork/Join Vs. ExecutorService in Java

Let's understand the major differences between Fork/Join framework and ExecutorService in Java with the help of a table.

Fork/Join Framework	ExecutorService
In Java 7, the Fork/Join framework can be defined as an implementation which follows the algorithm of divide and conquer. The branching ForkJoinTasks are executed with the help of a central ForkJoinPool.	In Java, ExecutorService can be defined as an executor that is responsible for providing methods and functions for management, tracking of progress, and stopping asynchronous tasks.
The Work Stealing algorithm is utilized or implemented by the Fork/Join framework. When a process or task is dependent on the completion of other sub-tasks that were created using the join operation, the worker thread that is currently executing the tasks will be looking for other tasks that have not been executed yet and borrows them for the purpose of executing them.	Whereas in ExecutorService, when a process or task keeps waiting for another sub-task to complete its execution that was created using the join operation, the thread responsible for executing that thread does not borrow other pending tasks to execute.
In Java, the Fork/Join framework is majorly utilized for solving problems related to recursion and in situations where a sub-task is required to run sub-tasks and then their results must be processed.	Unlike Fork/Join framework, problems related to recursion cannot be solved using the ExecutorService in Java. Because it will lead to threads being tied up and waiting for other threads results to be delivered to them.
In other words, the Fork/Join framework in Java is implemented using the ExecutorService in Java. The only main difference can be explained as the implementation of Fork/Join framework is responsible for creating a DEQUE worker pool.	Required number of threads can be created with the help of ExecutorService. Similarly, a blocking queue is applied which is utilized for storing all the remaining tasks which are in the waiting state.