All 15 Concurrency & Threads questions
More in Concurrency & Threads
What is thread starvation, and how can thread priority misuse or unfair lock scheduling contribute to it? What is the difference between wait()/notify()/notifyAll() (Object's intrinsic monitor methods) and the newer java.util.concurrent tools, and why are the older methods considered error-prone? What is a race condition, and how does it differ conceptually from a deadlock as two distinct categories of concurrency bugs? How does java.util.concurrent's ReentrantLock differ from the synchronized keyword, and what additional capabilities does it provide (tryLock, fairness, interruptible locking)? How does the Java Memory Model's happens-before relationship formally define when changes made by one thread are guaranteed to be visible to another thread, and what role does the volatile keyword play? How would you use CountDownLatch, CyclicBarrier, and Semaphore for different thread coordination scenarios, and what distinguishes their use cases? How does Java's virtual threads feature (Project Loom, finalized in Java 21) fundamentally change the thread-per-task model for high-concurrency applications, and how do they differ from traditional platform threads? How would you diagnose a suspected thread deadlock in a running production JVM using a thread dump, and what specific information in the dump reveals the deadlock?
Advertisement
Back to results for “Error Handling”
Java › Concurrency & Threads

How do CompletableFuture's composition methods (thenApply, thenCompose, thenCombine) enable building asynchronous pipelines, and what's the difference between thenApply and thenCompose?

Advanced

Answer

CompletableFuture represents a value that will be available asynchronously in the future, with fluent composition methods letting you chain dependent asynchronous operations without manually blocking and coordinating threads yourself -- thenApply(Function) transforms the eventual result synchronously within the same stage (for a simple, non-async transformation), while thenCompose(Function returning another CompletableFuture) is used specifically when your transformation itself returns another asynchronous operation, flattening what would otherwise become a nested CompletableFuture<CompletableFuture<T>> into a single CompletableFuture<T> (analogous to flatMap versus map in Streams/Optional), and thenCombine merges two independent CompletableFutures once both complete.
CompletableFuture<User> userFuture = fetchUserAsync(userId);

// thenApply: simple synchronous transformation of the result
CompletableFuture<String> nameFuture = userFuture.thenApply(User::getName);

// thenCompose: chaining another ASYNC operation, avoiding nested CompletableFuture<CompletableFuture<T>>
CompletableFuture<List<Order>> ordersFuture = userFuture.thenCompose(user -> fetchOrdersAsync(user.getId()));

// thenCombine: merge two independent async operations once both complete
CompletableFuture<Report> reportFuture = userFuture.thenCombine(fetchInventoryAsync(), (user, inventory) -> buildReport(user, inventory));
Real-world example A microservice orchestrating calls to three downstream services (user info, order history, and inventory) uses thenCompose to sequentially chain dependent async calls (fetching orders requires the user ID from the first call) and thenCombine to run two independent calls concurrently, composing the entire multi-service workflow declaratively without any manual thread coordination.

Common follow-ups: What happens to exceptions thrown partway through a CompletableFuture chain, and how does exceptionally()/handle() address this?;What thread does each stage of a CompletableFuture chain actually execute on by default?

Background Tasks & Hosted Services;Error Handling
All 15 Concurrency & Threads questions