Future Limitations: No Chaining or Composition
You'll learn why Future falls short when you need to combine or sequence multiple asynchronous operations.
The Core Problem
While Future is excellent for retrieving the result of a single asynchronous task, it provides no built-in way to chain operations or compose multiple async tasks together. Once you call get(), you're stuck blocking the current thread until the result arrives. If you want to perform another async operation based on that result, you have to manually submit another task and manage another Future—leading to clunky, nested code.
What's Missing?
Imagine you want to:
- Fetch user data asynchronously
- Then fetch their order history (requires the user ID from step 1)
- Then calculate a discount based on the orders
With Future, you'd write something like:
Future<User> userFuture = executor.submit(() -> fetchUser());
User user = userFuture.get(); // blocking!
Future<Orders> ordersFuture = executor.submit(() -> fetchOrders(user.getId()));
Orders orders = ordersFuture.get(); // blocking again!
Future<Discount> discountFuture = executor.submit(() -> calculateDiscount(orders));
Discount discount = discountFuture.get(); // more blocking!
Notice how each step blocks, waiting for the previous one? This defeats the purpose of asynchronous programming. You can't say "when this finishes, automatically do that next."
The Real-World Pain
Future also lacks methods to combine multiple independent futures (like "wait for both A and B, then combine their results") or handle exceptions gracefully without wrapping everything in try-catch blocks around get().
Key Takeaway:
Future is limited to single, isolated async results; it cannot chain dependent operations or compose multiple async tasks without manual, blocking coordination—motivating the need for CompletableFuture.