ExecutorService, Future & CompletableFuture

-

After understanding threads and multithreading basics, the next step in modern Java concurrency is learning how to manage threads efficiently. Manually creating threads is inefficient, difficult to control, and not scalable. Java solves these issues using ExecutorService, Future, and CompletableFuture.


Why ExecutorService?

ExecutorService provides a flexible framework for managing and reusing threads. It removes the need to manually create, start, and manage individual threads.

  • Efficient resource utilization
  • Thread reuse using thread pools
  • Better performance
  • Simpler asynchronous programming
  • Avoids creating too many threads

Types of Executor Services

Java offers several ready-to-use executors based on usage:

  • newSingleThreadExecutor: Executes tasks sequentially in one thread.
  • newFixedThreadPool: Maintains a fixed number of threads.
  • newCachedThreadPool: Creates threads as needed; good for short-lived tasks.
  • newScheduledThreadPool: Executes delayed and periodic tasks.

Submitting Tasks

ExecutorService lets you submit tasks instead of manually starting threads. You can submit both Runnable and Callable tasks using the submit() method.

Future – Handling Asynchronous Results

Future represents the output of an asynchronous task. When you submit a Callable, the method returns a Future object that you can use to:

  • Check if a task is completed
  • Cancel the task
  • Retrieve results using get()

Future helps manage long-running tasks without blocking the main thread.

Limitations of Future

Although useful, Future has limitations:

  • No callback mechanism
  • No chaining of tasks
  • get() blocks the thread

To overcome these, Java introduced CompletableFuture.

CompletableFuture – Modern Asynchronous Programming

CompletableFuture is a powerful API for building non-blocking, asynchronous, and event-driven systems. It supports chaining, combining multiple tasks, and writing clean concurrent code.

Main Features of CompletableFuture

  • runAsync – executes a task asynchronously
  • supplyAsync – executes and returns a result
  • thenApply – transforms the result
  • thenAccept – consumes the result
  • thenRun – runs a new task after completion
  • allOf – waits for multiple tasks
  • anyOf – returns the first completed result

CompletableFuture supports both non-blocking (callbacks) and blocking (get) operations, making it suitable for modern reactive systems.

Why Use ExecutorService + CompletableFuture?

Combining thread pools with CompletableFuture allows efficient and scalable async programming:

  • Reduces context switching
  • Improves performance
  • Keeps CPU busy without creating new threads
  • Allows structured concurrency

Shutting Down Executors

Always shut down the executor after use:

  • shutdown() – finishes ongoing tasks
  • shutdownNow() – stops tasks immediately

Not shutting down executors can lead to memory leaks and thread exhaustion.

Common Use Cases

  • Asynchronous APIs
  • Parallel computation
  • Microservices communication
  • Web request processing
  • Batch jobs

ExecutorService, Future, and CompletableFuture form the core of modern Java concurrency, enabling scalable and high-performance applications.

Comments

Post a Comment

Popular posts from this blog

Spring Boot on AWS EC2: Upload to S3 Securely Using IAM Role

-
When running a Spring Boot application on AWS EC2 , the most common security mistake is hardcoding AWS access keys inside application.properties . This is unnecessary and risky. AWS already provides a secure mechanism: IAM Roles attached to EC2 . In this blog, you will learn how to upload and download files to Amazon S3 from Spring Boot running on EC2 without any access keys , using: Spring Profiles AWS SDK v2 Instance Metadata Service (IMDS) IAM Roles Why Access Keys Are a Bad Idea on EC2 Typical S3 setups use: Access key Secret key Region Bucket This works only for local development. It should NOT be used on EC2. Problems with access keys: Stored in config or code (high risk) Might leak through Git, logs, or screenshots Require manual rotation Not needed if app runs on EC2 AWS automatically manages temporary credentials using the EC2 Instance Profile (IAM Role) . Architecture: EC2 → IAM Role → S3 Spring Boot app r...
Read more

Java Streams Intermediate Operations Explained with Examples

-
Image
The Java Stream API lets you process collections in a fluent, declarative style. In this post, we’ll walk through the most useful intermediate operations with simple examples. Note: Examples below use Java 8 compatible collect(Collectors.toList()) . If you’re on Java 16+, you can replace it with toList() . 1) filter() — Select elements by a condition Keeps only elements that match the predicate. List<Integer> list = Arrays.asList(1,2,3,4,5,6,7,8,9,10); List<Integer> res = list.stream() .filter(num -> num % 2 != 0) // keep only odd numbers .collect(Collectors.toList()); System.out.println(res); // [1, 3, 5, 7, 9] 2) map() — Transform each element Applies a function to every element and returns a stream of results. List<String> strs = Arrays.asList("rama", "anjaneya", "krishna"); List<String> upper = strs.stream() .map(String::toUpperCase) .collect(Collectors.toList()); System.o...
Read more

ConcurrentHashMap vs Synchronized HashMap in Java

-
Image
Introduction In multi-threaded Java applications, managing shared data safely and efficiently is crucial. Two common approaches are using Synchronized HashMap (via Collections.synchronizedMap(...) ) and ConcurrentHashMap . While both aim to provide thread-safety, their implementations and performance characteristics differ significantly. This post explores these differences in detail. What is a Synchronized HashMap? Created by wrapping a regular HashMap using: Map<K, V> syncMap = Collections.synchronizedMap(new HashMap<>()); Enforces synchronization at the object level , meaning only one thread can access the map at any time (read or write). Supports null keys and values since it relies on HashMap behavior. Iterators are fail-fast , throwing ConcurrentModificationException if the map is modified while iterating. Simpler implementation, suitable when concurrency is low or performance is not cri...
Read more