Java Multithreading & Concurrency: ExecutorService and ForkJoinPool Tutorial

The ExecutorService is a higher-level replacement for working with threads directly. It manages a pool of threads and allows you to submit tasks for execution.

• Key Features:
  • Manages a pool of threads to execute tasks.
  • Supports task submission, execution, and shutdown.
  • Provides methods for tracking task completion (e.g., Future).
• Creating an ExecutorService:
  Edit Copy

  import java.util.concurrent.ExecutorService;
  import java.util.concurrent.Executors;
  
  public class Main {
      public static void main(String[] args) {
          ExecutorService executor = Executors.newFixedThreadPool(4); // Create a thread pool with 4 threads
  
          for (int i = 0; i < 10; i++) {
              executor.submit(() -> {
                  System.out.println("Task executed by " + Thread.currentThread().getName());
              });
          }
  
          executor.shutdown(); // Shutdown the executor
      }
  }

• Using Future:
  Edit Copy

  import java.util.concurrent.*;
  
  public class Main {
      public static void main(String[] args) throws ExecutionException, InterruptedException {
          ExecutorService executor = Executors.newSingleThreadExecutor();
          Future<Integer> future = executor.submit(() -> {
              Thread.sleep(1000);
              return 42;
          });
  
          System.out.println("Result: " + future.get()); // Blocks until the result is available
          executor.shutdown();
      }
  }

The ForkJoinPool is a special thread pool designed for parallel execution of tasks that can be broken down into smaller subtasks. It is particularly useful for divide-and-conquer algorithms.

• Key Features:
  • Optimized for recursive task splitting and parallel execution.
  • Uses work-stealing to balance the load across threads.
  • Supports tasks of type ForkJoinTask (e.g., RecursiveTask, RecursiveAction).
• Example: RecursiveTask:
  Edit Copy

  import java.util.concurrent.*;
  
  class SumTask extends RecursiveTask {
      private final long[] numbers;
      private final int start;
      private final int end;
  
      SumTask(long[] numbers, int start, int end) {
          this.numbers = numbers;
          this.start = start;
          this.end = end;
      }
  
      @Override
      protected Long compute() {
          if (end - start <= 1000) { // Base case
              long sum = 0;
              for (int i = start; i < end; i++) {
                  sum += numbers[i];
              }
              return sum;
          } else { // Split task
              int mid = (start + end) / 2;
              SumTask leftTask = new SumTask(numbers, start, mid);
              SumTask rightTask = new SumTask(numbers, mid, end);
              leftTask.fork(); // Asynchronously execute the left task
              return rightTask.compute() + leftTask.join(); // Wait for the left task and combine results
          }
      }
  }
  
  public class Main {
      public static void main(String[] args) {
          long[] numbers = new long[10_000];
          for (int i = 0; i < numbers.length; i++) {
              numbers[i] = i + 1;
          }
  
          ForkJoinPool pool = new ForkJoinPool();
          long result = pool.invoke(new SumTask(numbers, 0, numbers.length));
          System.out.println("Sum: " + result); // Output: Sum: 50005000
      }
  }

Selecting the right tool depends on your specific use case:

• Use ExecutorService:
  • For general-purpose thread pooling.
  • When tasks are independent and do not need to be split into subtasks.
• Use ForkJoinPool:
  • For divide-and-conquer algorithms.
  • When tasks can be recursively split into smaller subtasks.