Description / Meta Description

Learn CompletableFuture in Java from the ground up. Understand the evolution of asynchronous programming from Thread, Runnable, Callable, Future, ExecutorService, CompletableFuture, and Virtual Threads. Explore real-world examples, execution flows, performance benefits, best practices, and common pitfalls in modern Java applications.

Modern applications rarely execute a single task at a time.

A typical request may involve:

Database Call
      ↓
REST API Call
      ↓
Cache Lookup
      ↓
Kafka Publish
      ↓
Email Notification

If each operation executes sequentially, users experience higher latency and systems process fewer requests.

This is where asynchronous programming becomes critical.

In this article we’ll understand:

Evolution of Java concurrency
Thread vs Future vs CompletableFuture
Asynchronous execution
Parallel execution
Chaining tasks
Combining multiple tasks
Exception handling
Performance optimization
Virtual Threads and Java 21+
Real-world Spring Boot examples

The Evolution of Asynchronous Programming in Java

Java concurrency evolved significantly over the years.

Java 1.0: Thread

The original approach was:

Thread thread =
    new Thread(() -> {

        System.out.println(
            "Running Task");
    });

thread.start();

Simple.

But problematic.

Imagine:

1000 Requests

Creating:

1000 Threads

becomes expensive.

Problems:

High memory consumption
Context switching
Difficult thread management

Java 5: ExecutorService

Java introduced thread pools.

ExecutorService executor =
    Executors.newFixedThreadPool(10);

executor.submit(() -> {

    System.out.println(
        "Task Executed");
});

Benefits:

Reuse Threads
Controlled Concurrency
Improved Performance

A major improvement.

Java 5: Callable and Future

Runnable couldn’t return values.

Java introduced:

Callable<String>

Example:

Future<String> future =
    executor.submit(() -> {

        return "Hello";
    });

String result =
    future.get();

Output:

Hello

Much better.

But there was a problem.

Future’s Biggest Limitation

Future supports:

future.get();

which blocks.

Example:

String value =
    future.get();

Execution pauses until completion.

This defeats many benefits of asynchronous programming.

Future also lacks:

Task Chaining
Task Composition
Callbacks
Exception Pipelines

Java 8: CompletableFuture Arrives

Java 8 introduced:

CompletableFuture

One of the most important additions to the Java platform.

CompletableFuture provides:

Asynchronous Execution
Callbacks
Task Chaining
Parallel Processing
Exception Handling
Composition

without blocking threads.

Understanding CompletableFuture

Think of CompletableFuture as:

A Promise
Of A Future Result

Example:

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> {

        return "Hello";
    });

The task starts asynchronously.

Meanwhile:

System.out.println(
    "Main Thread Continues");

can execute immediately.

Visualizing Execution

Traditional:

Task 1
   ↓
Task 2
   ↓
Task 3

Sequential.

CompletableFuture:

Task 1 ─┐
        ├── Execute In Parallel
Task 2 ─┤
        │
Task 3 ─┘

Faster execution.

Creating a CompletableFuture

Using:

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> {

        return "Processing";
    });

Retrieve result:

String result =
    future.join();

Output:

Processing

supplyAsync vs runAsync

Two commonly used methods.

runAsync()

Used when:

No Return Value

Example:

CompletableFuture.runAsync(() -> {

    System.out.println(
        "Task Executed");
});

Returns:

CompletableFuture<Void>

supplyAsync()

Used when:

Return Value Required

Example:

CompletableFuture<String> future =
    CompletableFuture.supplyAsync(() -> {

        return "Hello";
    });

Returns:

CompletableFuture<String>

Chaining Operations

One of the biggest advantages.

Suppose:

Get User
    ↓
Get Orders
    ↓
Generate Summary

Using CompletableFuture:

CompletableFuture
    .supplyAsync(() -> getUser())
    .thenApply(user ->
            getOrders(user))
    .thenApply(orders ->
            generateSummary(orders));

Each step executes after the previous completes.

No manual orchestration.

thenApply()

Transforms results.

Example:

CompletableFuture<Integer> future =
    CompletableFuture
        .supplyAsync(() -> 10)
        .thenApply(x -> x * 2);

Result:

Think:

map()
for CompletableFuture

thenAccept()

Consumes result.

CompletableFuture
    .supplyAsync(() -> "Hello")
    .thenAccept(System.out::println);

Output:

Hello

No value returned.

thenRun()

Runs another task.

CompletableFuture
    .runAsync(() -> {

        System.out.println(
            "Task 1");
    })
    .thenRun(() -> {

        System.out.println(
            "Task 2");
    });

Parallel API Calls Example

Imagine an e-commerce dashboard.

Need:

User Details
Order History
Reward Points

Sequential:

500 ms
+
500 ms
+
500 ms

=
1500 ms

Using CompletableFuture:

CompletableFuture<User> user =
    CompletableFuture
        .supplyAsync(this::getUser);

CompletableFuture<List<Order>> orders =
    CompletableFuture
        .supplyAsync(this::getOrders);

CompletableFuture<Integer> points =
    CompletableFuture
        .supplyAsync(this::getPoints);

Execute simultaneously.

Total:

≈ 500 ms

instead of:

1500 ms

Huge performance gain.

Combining Results

Use:

thenCombine()

Example:

user.thenCombine(
        points,
        (u, p) ->
            buildProfile(u, p));

Combines two futures.

Waiting for Multiple Tasks

Use:

CompletableFuture.allOf()

Example:

CompletableFuture.allOf(
    user,
    orders,
    points
).join();

Waits for all tasks.

Visual:

User
  │
Orders
  │
Points
  │
  ▼

All Complete

Any Task Completion

Use:

CompletableFuture.anyOf()

Example:

CompletableFuture.anyOf(
    service1,
    service2,
    service3);

Returns first completed result.

Useful for:

Fastest Response Wins

patterns.

Exception Handling

A critical feature.

Without handling:

One Failure
=
Broken Pipeline

Using exceptionally()

CompletableFuture
    .supplyAsync(() -> {

        throw new RuntimeException();
    })
    .exceptionally(ex -> {

        return "Fallback";
    });

Result:

Fallback

handle()

Allows success and failure processing.

future.handle((result, ex) -> {

    if(ex != null) {

        return "Default";
    }

    return result;
});

Custom Thread Pools

By default:

ForkJoinPool.commonPool()

is used.

Production systems often require dedicated pools.

Example:

ExecutorService executor =
    Executors.newFixedThreadPool(20);

CompletableFuture
    .supplyAsync(
        this::process,
        executor);

Benefits:

Isolation
Capacity Control
Predictable Performance

Spring Boot Example

Traditional:

User user =
    userService.getUser();

Orders orders =
    orderService.getOrders();

Sequential.

Using CompletableFuture:

CompletableFuture<User> user =
        userService.getUserAsync();

CompletableFuture<Orders> orders =
        orderService.getOrdersAsync();

CompletableFuture.allOf(
        user,
        orders)
        .join();

Parallel execution.

Faster response times.

Common Production Use Cases

API Aggregation

Profile Service
Order Service
Rewards Service

Combine results.

Dashboard Generation

Widgets Loaded In Parallel

Report Generation

Multiple Data Sources

Data Synchronization

Parallel Fetches

ETL Pipelines

Extract
Transform
Load

with asynchronous stages.

Java 9 Improvements

Java 9 added:

orTimeout()

completeOnTimeout()

Example:

future.orTimeout(
    2,
    TimeUnit.SECONDS);

Prevents hanging tasks.

Java 12+ Enhancements

Improved:

Performance
Thread Management
ForkJoin Optimizations

making CompletableFuture more efficient.

Java 21+: Virtual Threads

Java introduced:

Thread.ofVirtual()

through Project Loom.

Example:

Thread.startVirtualThread(() -> {

    callDatabase();
});

Now:

Millions Of Threads

become feasible.

CompletableFuture vs Virtual Threads

This is the modern interview question.

CompletableFuture

Solves:

Task Composition
Parallel Execution
Non-Blocking Pipelines

Virtual Threads

Solves:

Cheap Thread Creation
Simpler Programming Model

CompletableFuture:

thenApply()
thenCombine()
allOf()

provides powerful orchestration.

Virtual Threads do not.

Modern Recommendation

For:

Parallel API Calls
Pipeline Processing
Task Composition

Use:

CompletableFuture

For:

Traditional Blocking Code
Large Concurrency
Simple Logic

Use:

Virtual Threads

Often:

Virtual Threads
+
CompletableFuture

work beautifully together.

Common Mistakes

Calling get() Everywhere

Bad:

future.get();

repeatedly.

Creates blocking code.

Ignoring Exception Handling

Always use:

exceptionally()

handle()

for resilience.

Using CommonPool For Everything

Large systems should use dedicated executors.

Creating Massive Async Chains

Keep pipelines readable.

Break large workflows into smaller components.

CompletableFuture Cheat Sheet

runAsync()
→ Fire And Forget

supplyAsync()
→ Return Value

thenApply()
→ Transform Result

thenAccept()
→ Consume Result

thenRun()
→ Execute Next Task

thenCombine()
→ Combine Results

allOf()
→ Wait For All

anyOf()
→ Wait For First

exceptionally()
→ Handle Errors

handle()
→ Success Or Failure

Final Thoughts

CompletableFuture fundamentally changed Java asynchronous programming.

It solved many limitations of:

Thread
Runnable
Callable
Future

and introduced a powerful model for:

Asynchronous execution
Task composition
Parallel processing
Exception handling
Non-blocking workflows

Even with the arrival of Virtual Threads in Java 21+, CompletableFuture remains one of the most important concurrency tools available to Java developers.

If you’re building:

Spring Boot APIs
Microservices
Batch Systems
Data Pipelines
Integration Platforms

mastering CompletableFuture will help you build faster, more scalable, and more resilient applications.

The real power of CompletableFuture is not simply running code asynchronously.

It is expressing complex workflows declaratively while letting the JVM efficiently orchestrate execution behind the scenes.

Description / Meta Description

The Evolution of Asynchronous Programming in Java

Java 1.0: Thread

Java 5: ExecutorService

Java 5: Callable and Future

Future’s Biggest Limitation

Java 8: CompletableFuture Arrives

Understanding CompletableFuture

Visualizing Execution

Creating a CompletableFuture

supplyAsync vs runAsync

runAsync()

supplyAsync()

Chaining Operations

thenApply()

thenAccept()

thenRun()

Parallel API Calls Example

Combining Results

Waiting for Multiple Tasks

Any Task Completion

Exception Handling

handle()

Custom Thread Pools

Spring Boot Example

Common Production Use Cases

API Aggregation

Dashboard Generation

Report Generation

Data Synchronization

ETL Pipelines

Java 9 Improvements

Java 12+ Enhancements

Java 21+: Virtual Threads

CompletableFuture vs Virtual Threads

CompletableFuture

Virtual Threads

Modern Recommendation

Common Mistakes

Calling get() Everywhere

Ignoring Exception Handling

Using CommonPool For Everything

Creating Massive Async Chains

CompletableFuture Cheat Sheet

Final Thoughts

Leave a Reply Cancel reply

Java – Design Patterns

Building an Annotation-Driven Enterprise Cache Framework for Spring Boot Microservices

Java OCP Programming Challenge – Sets 9 to 11

10 Practical Java Interview Programming Exercises with Solutions, Logic and Complexity Analysis