Callable, Future, and CompletableFuture

The java.util.concurrent package gives Java richer tools than raw Thread and Runnable for running work asynchronously and getting a result back. Callable extends the idea of a background task to one that can return a value and throw checked exceptions, Future represents the eventual result of that task, and CompletableFuture builds on both to let you chain and combine asynchronous operations without blocking the calling thread at every step.

Why it matters

A Runnable cannot return a result. Callable and Future fix that, but Future.get() blocks the calling thread. CompletableFuture goes further: it lets you describe what should happen when a result arrives and combine several results, without blocking. It is the basis of most asynchronous Java code written today.

Callable vs Runnable

Runnable's single method, run(), returns void and cannot throw any checked exception. Callable<V>'s single method, call(), returns a value of type V and is allowed to throw a checked Exception. This makes Callable the right choice whenever a background task needs to produce a result (a computed number, a fetched record) or may naturally fail with a checked exception (such as an I/O operation), which Runnable simply cannot express.

Submitting a Callable and Getting a Future

An ExecutorService (obtained, for example, from Executors.newSingleThreadExecutor() or Executors.newFixedThreadPool(n)) manages a pool of worker threads and can run tasks on them. Calling executor.submit(callable) schedules the Callable to run on one of those threads and immediately returns a Future<V> — a handle representing a result that may not exist yet. The calling thread can continue doing other work while the task runs in the background.

Future.get() and Blocking

Calling future.get() retrieves the task's result once it is available. If the task has already finished, get() returns immediately; if it is still running, get() blocks — the calling thread pauses — until the task completes (or an overloaded, timed version of get(timeout, unit) gives up after a timeout and throws a TimeoutException instead). If the Callable itself threw an exception, get() wraps it in an ExecutionException and rethrows that. Because plain Future only offers this blocking retrieval, and no built-in way to chain further work onto a Future's eventual result, composing multiple dependent async steps with raw Future quickly becomes awkward.

CompletableFuture: Composing Async Work Without Blocking

CompletableFuture<T> implements Future<T> but adds a large API for describing what should happen next, without forcing the calling thread to block and wait first. CompletableFuture.supplyAsync(supplier) starts an asynchronous computation and returns immediately. thenApply(function) transforms the eventual result once it arrives. thenCombine(otherFuture, function) waits for two independent CompletableFutures and combines their results together. exceptionally(function) supplies a fallback value if the computation completed with an exception instead of a result, letting you recover gracefully rather than propagating the failure. These methods return new CompletableFutures, so calls can be chained fluently to describe an entire asynchronous pipeline before any blocking call is made.

Examples

import java.util.concurrent.*;

public class CallableFutureDemo {
    public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();

        Callable<Integer> task = () -> {
            Thread.sleep(100);
            return 10 * 5;
        };

        Future<Integer> future = executor.submit(task);
        System.out.println("Task submitted, doing other work...");

        Integer result = future.get(); // blocks until the task finishes
        System.out.println("Result: " + result);

        executor.shutdown();
    }
}

Task submitted, doing other work...
Result: 50

import java.util.concurrent.CompletableFuture;

public class CompletableFutureDemo {
    public static void main(String[] args) throws Exception {
        CompletableFuture<Integer> priceFuture = CompletableFuture.supplyAsync(() -> 200);
        CompletableFuture<Integer> taxFuture = CompletableFuture.supplyAsync(() -> 20);

        CompletableFuture<Integer> totalFuture = priceFuture
                .thenCombine(taxFuture, (price, tax) -> price + tax)
                .thenApply(total -> total * 1);

        System.out.println("Total: " + totalFuture.get());

        CompletableFuture<Integer> safeFuture = CompletableFuture
                .supplyAsync(() -> 10 / 0)
                .exceptionally(ex -> -1);

        System.out.println("Safe result: " + safeFuture.get());
    }
}

Total: 220
Safe result: -1

Exercise

Build a small asynchronous pipeline with CompletableFuture: produce 20 asynchronously, double it, then add the result of a second asynchronous task that produces 2. Print the final value.

Expected output: 42

import java.util.concurrent.CompletableFuture;

public class AsyncPipeline {
    public static void main(String[] args) {
        CompletableFuture<Integer> first = CompletableFuture.supplyAsync(() -> 20);
        CompletableFuture<Integer> second = CompletableFuture.supplyAsync(() -> 2);

        // TODO: double the first value, then combine it with the second by adding them
        // TODO: wait for the result with join() and print it
    }
}

import java.util.concurrent.CompletableFuture;

public class AsyncPipeline {
    public static void main(String[] args) {
        CompletableFuture<Integer> first = CompletableFuture.supplyAsync(() -> 20);
        CompletableFuture<Integer> second = CompletableFuture.supplyAsync(() -> 2);

        CompletableFuture<Integer> result = first
                .thenApply(value -> value * 2)
                .thenCombine(second, Integer::sum);

        System.out.println(result.join()); // 42
    }
}

Quick quiz

Interview questions