This week, I’m diving into Java’s CompletableFuture.
As a full-stack developer with a frontend background, dealing with asynchronous tasks is an inevitable part of my role – network requests, background computations, and the like. In Java, CompletableFuture is a powerful tool for handling these tasks while keeping the main thread responsive.
Completable futures are to Java what Promises are to JavaScript.
If you’re familiar with JavaScript, it might help to grasp these concepts by making parallels between both languages. I like to think of CompletableFuture as Java’s version of a Promise. It is a class that represents the eventual result of an asynchronous operation, whether that result is a success or failure. Introduced in Java 8 as part of the java.util.concurrent package, it’s a powerful way of writing non-blocking code, with methods for chaining operations, and handling errors, similarly to Promises.
Here’s a quick comparison of the two:
fetchFromServer()
.then(data => processData(data))
.then(result => updateUI(result))
.catch(error => handleError(error));
CompletableFuture.supplyAsync(() -> fetchDataFromServer())
.thenApply(data -> processData(data))
.thenAccept(result -> updateUI(result))
.exceptionally(error -> handleError(error));
As illustrated above, CompletableFuture provides a similar, chainable syntax that allows for clean and readable asynchronous code.
Consider a scenario where you need to fetch a user’s profile data and order history from two separate endpoints. You would want to avoid freezing the UI while waiting for these requests to complete. Here’s how you would implement this using CompletableFuture:
// Fetch user profile from a service
});
CompletableFuture<List<Order>> ordersFuture = CompletableFuture.supplyAsync(() -> {
// Fetch user orders from another service
});
CompletableFuture<Void> combinedFuture = CompletableFuture.allOf(profileFuture, ordersFuture);
combinedFuture.thenRun(() -> {
User user = userFuture.join();
List<Order> orders = ordersFuture.join();
displayUserData(user, orders);
});
In this example, we trigger two asynchronous requests simultaneously and use allOf to wait for both to finish. Once they complete, we retrieve the results and update the UI accordingly, all without blocking the main thread.
Chaining & CompletionStage
CompletableFuture implements the CompletionStage interface, which provides the foundation for chaining operations. Each thenApply, thenAccept, and similar method returns another CompletionStage, allowing you to create complex asynchronous pipelines.
Similar to how we can chain promises in JavaScript when we have a sequence of asynchronous tasks to be performed one after another, we can chain tasks within a Completable Future in order to create a sequence of dependent asynchronous operations without falling into callback hell. Here’s how we would do that:
.thenApply(result -> result + “, CompletableFuture”)
.thenApply(result -> result + ” in Java”)
.thenAccept(System.out::println);
Handling exceptions
Where we have .catch() on a Promise object, we have .exceptionally() on a Completable Future. This method handles exceptions that may occur during asynchronous processing:
if (true) {
throw new RuntimeException(“Exception in CompletableFuture!”);
}
return “No exception”;
}).exceptionally(ex -> {
System.out.println(“Handled exception: “ + ex);
return “Recovered value”;
}).thenAccept(System.out::println);
I hope this article gives you a good starting point to explore the CompletableFuture class further.
Helpful Links:
Concurrency Deep Dives: A Guide to CompletableFuture
A Comprehensive Introduction to Asynchronous Programming in Java — Promises, Callbacks, and Futures
