Parallelism in Java: ForkJoinPool, Streams API, and CompletableFuture Explained

Unlock Parallelism: Conquer Java Concurrency!

Learn how to supercharge your Java applications with Parallelism using modern techniques. Discover ForkJoinPool, leverage the power of Streams API, and master asynchronous programming with CompletableFuture. Improve performance and responsiveness in your Java code!

Read More

Introduction to Parallelism in Java

Parallelism is a form of computation where multiple calculations are carried out simultaneously. In Java, this is crucial for enhancing the performance of applications, especially those dealing with large datasets or computationally intensive tasks. Java provides several tools to achieve parallelism, each with its own strengths and use cases.

ForkJoinPool: Divide and Conquer

The ForkJoinPool is an implementation of the ExecutorService interface that allows you to execute tasks in parallel using a divide-and-conquer approach. It is particularly effective for problems that can be broken down into smaller, independent subtasks.

Key Components of ForkJoinPool:

• ForkJoinPool: The main component that manages and executes ForkJoinTask instances.
• ForkJoinTask: An abstract class representing a task that can be split into smaller tasks.
• RecursiveTask: A subclass of ForkJoinTask that returns a result.
• RecursiveAction: A subclass of ForkJoinTask that does not return a result.

Example: Calculating Sum using RecursiveTask

 import java.util.concurrent.RecursiveTask;

 class SumTask extends RecursiveTask<Long> {
  private static final int THRESHOLD = 1000;
  private final long[] array;
  private final int start;
  private final int end;

  public SumTask(long[] array, int start, int end) {
   this.array = array;
   this.start = start;
   this.end = end;
  }

  @Override
  protected Long compute() {
   int length = end - start;
   if (length <= THRESHOLD) {
    long sum = 0;
    for (int i = start; i < end; i++) {
     sum += array[i];
    }
    return sum;
   } else {
    int middle = start + length / 2;
    SumTask leftTask = new SumTask(array, start, middle);
    SumTask rightTask = new SumTask(array, middle, end);
    leftTask.fork();
    long rightSum = rightTask.compute();
    long leftSum = leftTask.join();
    return leftSum + rightSum;
   }
  }
 }

 // Usage:
 // long[] numbers = ...;
 // ForkJoinPool pool = new ForkJoinPool();
 // SumTask task = new SumTask(numbers, 0, numbers.length);
 // long result = pool.invoke(task);
 

Streams API: Parallel Processing Made Easy

Java 8 introduced the Streams API, which provides a high-level abstraction for processing collections of data. Streams can be processed sequentially or in parallel, making it easy to leverage multi-core processors.

Parallel Streams:

To process a stream in parallel, you simply need to invoke the parallel() method on the stream.

Example: Parallel Processing with Streams

 import java.util.Arrays;

 public class ParallelStreamExample {
  public static void main(String[] args) {
   long[] numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

   long sum = Arrays.stream(numbers)
     .parallel()
     .filter(n -> n % 2 == 0)
     .map(n -> n * 2)
     .sum();

   System.out.println("Sum: " + sum); // Output: Sum: 60
  }
 }
 

CompletableFuture: Asynchronous Programming

CompletableFuture provides a powerful and flexible way to write asynchronous, non-blocking code. It allows you to compose, combine, and execute asynchronous computations in a clean and concise manner.

Key Features of CompletableFuture:

• Asynchronous Execution: Executes tasks in a separate thread.
• Composition: Allows combining multiple asynchronous tasks.
• Error Handling: Provides mechanisms to handle exceptions.
• Non-blocking: Doesn't block the main thread, improving responsiveness.

Example: Asynchronous Task with CompletableFuture

 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;

 public class CompletableFutureExample {
  public static void main(String[] args) throws ExecutionException, InterruptedException {
   CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
     Thread.sleep(2000); // Simulate long running task
    } catch (InterruptedException e) {
     Thread.currentThread().interrupt();
    }
    return "Hello, Asynchronous World!";
   });

   System.out.println("Doing something else...");

   String result = future.get(); // This will block until the future is complete
   System.out.println(result);
  }
 }
 

Conclusion

By following this guide, you’ve successfully understood and implemented parallelism in Java using ForkJoinPool, Streams API, and CompletableFuture. Happy coding!

Show your love, follow us javaoneworld