CompletableFuture: Future grows up

Key points

• Future.get() blocks - so "run in the background" ended with the caller waiting anyway.
• You could not combine two Futures, react to failure, or chain a next step without a thread parked on each.
• CompletableFuture adds callbacks: thenApply, thenCompose, thenCombine.
• Failure travels down the chain and is caught by exceptionally or handle.
• Async variants default to the common ForkJoinPool - pass your own executor for blocking I/O.

Example

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(2);
        try {
            CompletableFuture<String> user =
                CompletableFuture.supplyAsync(() -> "ada", pool);

            CompletableFuture<Integer> orders =
                CompletableFuture.supplyAsync(() -> 3, pool);

            // Combine two independent results without blocking on either
            String summary = user.thenCombine(orders, (u, n) -> u + " has " + n + " orders").get();
            System.out.println(summary);

            // Failure flows down the chain
            String recovered = CompletableFuture
                .<String>supplyAsync(() -> { throw new IllegalStateException("db down"); }, pool)
                .exceptionally(ex -> "recovered from: " + ex.getCause().getMessage())
                .get();
            System.out.println(recovered);
        } finally {
            pool.shutdown();
            pool.awaitTermination(2, TimeUnit.SECONDS);
        }
    }
}

CompletableFuture replaced "wait for the answer" with "tell me what to do when it arrives".