Mastering CompletableFuture: Boosting Asynchronous Performance in Java

Background

Shop‑detail page originally performed six RPC calls sequentially: base info (0.5 s), discount info (1 s), store info (1 s), inspection report (1 s), product parameters (1 s), and assembly (0.5 s). Total latency ≈5 s, which becomes unacceptable as QPS grows.

Parallelizing independent calls reduces overall latency to the longest branch, about 2 s.

Future and its limitations

Java 5 introduced Callable and Future. The interface provides cancel, isCancelled, isDone, get, and get(timeout,…). Drawbacks: get blocks the calling thread, and Future lacks composition, chaining, and built‑in exception handling.

package java.util.concurrent;
public interface Future<V> {
    boolean cancel(boolean mayInterruptIfRunning);
    boolean isCancelled();
    boolean isDone();
    V get() throws InterruptedException, ExecutionException;
    V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
}

CompletableFuture capabilities

Creating asynchronous tasks

public static CompletableFuture<Void> runAsync(Runnable runnable);
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);

If no executor is supplied, ForkJoinPool.commonPool() is used; production code should provide a custom thread pool to avoid contention.

Asynchronous callbacks

CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action);
<U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn);

Composition primitives

<U> CompletableFuture<U> thenApplyAsync(Function<? super T, ? extends U> fn);
CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);
static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);
static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs);

Solution for the shop‑detail page

Three logical steps:

Fetch base info, inspection report, product parameters, and store info in parallel.

After base info is ready, fetch discount info (depends on step 1).

When all parallel tasks finish, assemble the final DTO.

Because the overall latency equals the longest branch, the response time drops from ~5 s to ~2 s.

Implementation example

ExecutorService testThreadPool = Executors.newFixedThreadPool(10);
ResultDTO resultDTO = new ResultDTO();

// base info
CompletableFuture<Void> baseInfoFuture = CompletableFuture.runAsync(() -> {
    BaseInfoDTO baseInfoDTO = rpcCall();
    resultDTO.setBaseInfoDTO(baseInfoDTO);
}, testThreadPool);

// discount info (depends on base info)
CompletableFuture<Void> discountFuture = baseInfoFuture.thenAcceptAsync(() -> {
    CouponInfoDTO couponInfoDTO = rpcCall();
    resultDTO.setCouponInfoDTO(couponInfoDTO);
}, testThreadPool);

// inspection report
CompletableFuture<Void> qcFuture = CompletableFuture.runAsync(() -> {
    QcInfoDTO qcInfoDTO = rpcCall();
    resultDTO.setQcInfoDTO(qcInfoDTO);
}, testThreadPool);

// store info
CompletableFuture<Void> storeFuture = CompletableFuture.runAsync(() -> {
    StoreInfoDTO storeInfoDTO = rpcCall();
    resultDTO.setStoreInfoDTO(storeInfoDTO);
}, testThreadPool);

// product parameters
CompletableFuture<Void> spuFuture = CompletableFuture.runAsync(() -> {
    SpuInfoDTO spuInfoDTO = rpcCall();
    resultDTO.setSpuInfoDTO(spuInfoDTO);
}, testThreadPool);

// wait for all independent tasks
CompletableFuture<Void> all = CompletableFuture.allOf(discountFuture, qcFuture, storeFuture, spuFuture);

// assemble final result
CompletableFuture<Void> build = all.thenAcceptAsync(v -> {
    // combine fields into response object
}, testThreadPool).join();

Factory‑strategy refactoring

To eliminate repetitive boilerplate, each module can be represented by a handler obtained from a simple factory. Handlers are executed via CompletableFuture.allOf() on a list.

List<String> eventList = Arrays.asList("xx", "xxx");
CompletableFuture.allOf(
    eventList.stream()
        .map(event -> CompletableFuture.runAsync(() -> {
            // obtain handler from factory
            if (handler != null) {
                handler.handle(event);
            }
        }, testThreadPool))
        .toArray(CompletableFuture[]::new)
).join();

Key takeaways

Parallelize independent RPC calls with CompletableFuture to achieve significant latency reduction.

Use composition methods ( thenApplyAsync, allOf, anyOf) to build complex asynchronous pipelines.

Prefer a custom thread pool over the common pool to control resource usage and avoid contention.

When aggregating results, use thread‑safe DTOs or explicit synchronization.

Handle timeouts and exceptions explicitly (e.g., exceptionally) to prevent blocking the main thread.

References

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletableFuture.html

https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/CompletionStage.html