CompletableFuture

Introduced in Java 8, CompletableFuture implements Future and CompletionStage, enabling functional-style, event-driven asynchronous programming. It allows chaining operations and handling errors without blocking threads.

Core Chaining API Methods

These methods construct non-blocking pipelines:

• thenApply(Function): Transforms the result of the previous stage (analogous to map).
• thenAccept(Consumer): Consumes the final result without returning a value (ends the pipeline).
• thenCompose(Function): Flattens nested futures (analogous to flatMap). Use this if your transform function returns a new CompletableFuture.
• thenCombine(CompletionStage, BiFunction): Combines two independent futures concurrently, running a function when both complete.
• exceptionally(Function): Intercepts errors thrown anywhere in the chain and recovers with a fallback value.

Code Walkthrough

This program simulates an async pipeline fetching user IDs, retrieving email data, and recovering from errors.

import java.util.concurrent.CompletableFuture;
public class CompletableFutureDemo {
    public static void main(String[] args) throws InterruptedException {
        // Start async task using default ForkJoinPool
        CompletableFuture.supplyAsync(() -> {
            System.out.println("Fetching user ID...");
            return "user_123";
        })
        // Chain a dependent transformation
        .thenApply(userId -> {
            System.out.println("Constructing email...");
            return userId + "@example.com";
        })
        // Handle potential errors
        .exceptionally(throwable -> {
            return "fallback@example.com";
        })
        // Consume final value
        .thenAccept(email -> {
            System.out.println("Sending email to: " + email);
        });
Thread.sleep(1000); // Wait for async task execution to complete
    }
}

Interview-Relevant Information