public class ProductAggregator implements AutoCloseable {
private final RemoteServices services;
private final ExecutorService pool = Executors.newFixedThreadPool(8);
public ProductAggregator(RemoteServices services) {
this.services = services;
}
public CompletableFuture<ProductView> load(String productId) {
CompletableFuture<Price> price = CompletableFuture
.supplyAsync(() -> services.fetchPrice(productId), pool)
.orTimeout(400, TimeUnit.MILLISECONDS)
.exceptionally(ex -> Price.unavailable(productId));
CompletableFuture<Inventory> inventory = CompletableFuture
.supplyAsync(() -> services.fetchInventory(productId), pool)
.orTimeout(400, TimeUnit.MILLISECONDS)
.exceptionally(ex -> Inventory.unknown(productId));
CompletableFuture<List<Review>> reviews = CompletableFuture
.supplyAsync(() -> services.fetchReviews(productId), pool)
.orTimeout(600, TimeUnit.MILLISECONDS)
.exceptionally(ex -> Collections.emptyList());
return combineAll(productId, price, inventory, reviews);
}
private CompletableFuture<ProductView> combineAll(String productId,
CompletableFuture<Price> price,
CompletableFuture<Inventory> inventory,
CompletableFuture<List<Review>> reviews) {
return CompletableFuture
.allOf(price, inventory, reviews)
.thenApply(ignored -> new ProductView(
productId,
price.join(),
inventory.join(),
reviews.join()));
}
@Override
public void close() {
pool.shutdown();
}
}public class RemoteServices {
private final HttpClient http;
private final String baseUrl;
public RemoteServices(HttpClient http, String baseUrl) {
this.http = http;
this.baseUrl = baseUrl;
}
public Price fetchPrice(String productId) {
return get("/pricing/" + productId)
.thenApply(Price::fromJson)
.join();
}
public Inventory fetchInventory(String productId) {
return get("/inventory/" + productId)
.thenApply(Inventory::fromJson)
.join();
}
public List<Review> fetchReviews(String productId) {
return get("/reviews/" + productId)
.thenApply(Review::listFromJson)
.join();
}
private CompletableFuture<String> get(String path) {
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(baseUrl + path))
.header("Accept", "application/json")
.timeout(Duration.ofSeconds(2))
.GET()
.build();
return http
.sendAsync(request, HttpResponse.BodyHandlers.ofString())
.thenApply(HttpResponse::body);
}
}public final class ProductView {
private final String productId;
private final Price price;
private final Inventory inventory;
private final List<Review> reviews;
public ProductView(String productId, Price price, Inventory inventory, List<Review> reviews) {
this.productId = productId;
this.price = price;
this.inventory = inventory;
this.reviews = reviews;
}
public boolean isFullyLoaded() {
return price.isAvailable() && inventory.isKnown();
}
public double averageRating() {
return reviews.stream()
.mapToInt(Review::stars)
.average()
.orElse(0.0);
}
public String getProductId() {
return productId;
}
public Price getPrice() {
return price;
}
public Inventory getInventory() {
return inventory;
}
public List<Review> getReviews() {
return reviews;
}
}This snippet shows how to fan out several independent remote calls in parallel and combine their results into a single response using CompletableFuture, without blocking a thread per call. The example builds a product detail page that needs pricing, inventory, and review data from three separate services, each of which can be slow or fail on its own.
In ProductAggregator, each dependency is launched with CompletableFuture.supplyAsync, running on a bounded executor rather than the common ForkJoinPool, which is important because the work is IO-bound and the common pool is shared across the JVM. The three futures start immediately and run concurrently; the code only waits once, at the join point. orTimeout bounds each call so one hung service cannot stall the whole aggregation, and exceptionally converts a failure into a safe fallback value so a single degraded dependency does not fail the entire page. This is the resilience trade-off: partial data is preferred over no data.
The combination happens in combineAll, which uses CompletableFuture.allOf to produce a future that completes only when every input has settled. Because each individual future already handled its own timeout and error, the join calls inside the final thenApply never block for long and never throw — they simply read the already-computed values. This separation, per-future resilience first, then aggregation, is what keeps the combining logic clean.
RemoteServices wraps the JDK HttpClient and returns futures directly via sendAsync, so no thread is parked waiting on the network. The service methods also demonstrate mapping a raw HTTP body into a domain object inside thenApply, keeping parsing off the calling thread.
A key pitfall the code avoids is calling join on each future sequentially, which would serialize the calls and defeat the purpose. Another is forgetting to shut the executor down; ProductAggregator exposes close so the pool is released. This pattern fits any read path that gathers from multiple sources, such as dashboards, search enrichment, or checkout summaries, where latency is dominated by the slowest dependency rather than the sum of them.
Related snips
export interface RetryOptions {
retries: number;
baseMs: number;
maxMs: number;
signal?: AbortSignal;
onRetry?: (attempt: number, delay: number, err: unknown) => void;Exponential backoff with jitter for retries
type User {
id: ID!
name: String!
email: String!
posts: [Post!]!
createdAt: String!GraphQL API with Spring Boot
use crossbeam::channel::unbounded;
use std::thread;
fn main() {
let (tx, rx) = unbounded();Crossbeam for advanced concurrent data structures
// Creating a Promise
const myPromise = new Promise((resolve, reject) => {
const success = true;
setTimeout(() => {
if (success) {Promises and async/await patterns for asynchronous JavaScript
use std::sync::mpsc;
use std::thread;
fn main() {
let (tx, rx) = mpsc::channel();Channels (mpsc) for message passing between threads
export type Settled<R> =
| { status: 'fulfilled'; value: R }
| { status: 'rejected'; reason: unknown };
export interface ConcurrencyOptions {
limit: number;Simple concurrency limiter for batch operations
Share this code
Here's the card — post it anywhere.
