CompletableFuture is a powerful asynchronous programming tool introduced by Java 8. It implements the Future and CompletionStage interfaces, allowing chain processing, combination and exception management of asynchronous operations. 1. It implements asynchronous task execution through runAsync() and supplyAsync() methods; 2. Supports operation chain calls using thenApply, thenAccept and thenRun; 3. ThenCompose and thenCombine are used to combine multiple asynchronous operations; 4. Exceptionally and handle methods provide exception handling mechanisms; 5. It is recommended to use it in combination with custom thread pools to avoid blocking the public thread pool, and emphasize that error handling logic must be included in production code.

Asynchronous programming is a must-have skill these days, especially when dealing with I/O-bound operations or trying to scale applications efficiently. In Java, one of the most powerful tools for handling async tasks is CompletableFuture . It gives you fine-grained control over asynchronous operations and makes chaining, combining, and error handling much easier than using raw threads or even Future .

What is CompleteFuture?

CompletableFuture was introduced in Java 8 as part of the java.util.concurrent package. It's an implementation of the Future interface that also implements the CompletionStage interface. This means it not only allows you to get the result of an asynchronous computing but also enables you to chain dependent actions, handle exceptions, and combine multiple futures.

Think of it like this: instead of waiting for a task to finish before moving on, you can define what should happen once it finishes — all without blocking your main thread.

Starting Simple: Running Async Tasks

The simplest use case is running a task asynchronously. You can do this using methods like runAsync() (for Runnable ) or supplyAsync() (for Supplier ).

 CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // Simulate long-running task
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    }
    return "Hello from async";
});

This creates a task that runs in a separate thread (by default using ForkJoinPool.commonPool() , unless you specify another executor). You can later retrieve the result by calling future.get() .

A few things to note:

• If you're doing blocking I/O, consider supplying your own executor to avoid starving the common pool.
• Don't forget to handle interruptions properly.
• Use supplyAsync when you expect a return value; use runAsync if you don't.

Chaining Operations: thenApply, thenAccept, thenRun

Once you have a future, you often want to do something with its result. That's where chaining comes in.

Here are three commonly used methods:

• thenApply : transforms the result
• thenAccept : consumes the result (no return)
• thenRun : runs a task after completion (ignores result)

Example:

 CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(s -> s.length())
    .thenApply(len -> len * 2);

This returns a CompletableFuture<Integer> that will eventually resolve to 10 .

Use cases:

• Transforming data between stages
• Logging intermediate results
• Triggering side effects based on outcome

Tip: Keep transformations simple in each stage. Complex logic inside a single thenApply can make debugging harder.

Combining Futures: thenCompose and thenCombine

Sometimes you need to run two related async operations in sequence or parallel.

• thenCompose is used when you want to chain futures sequentially (ie, result of first is input to second).
• thenCombine is for parallel execution where you want to combine the results afterward.

Example with thenCompose :

 CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = future1.thenCompose(s -> CompletableFuture.supplyAsync(() -> s "World"));

Example with thenCombine :

 CompleteFuture<Integer> futureA = CompleteFuture.supplyAsync(() -> 10);
CompleteFuture<Integer> futureB = CompleteFuture.supplyAsync(() -> 20);
CompleteFuture<Integer> combined = futureA.thenCombine(futureB, (a, b) -> ab);

These methods are useful when:

• You need to aggregate data from multiple services
• You want to avoid callback hell by flattening nested futures
• You're building pipelines that require both serial and parallel steps

Handling Errors Gracefully with exceptionally or handle

Unpredictable things happen in async code — network failures, timeouts, etc. So knowing how to recover or fallback is important.

You can use:

• exceptionally(Function<Throwable, ? extends T>) to provide a fallback value
• handle(BiFunction<T, Throwable, R>) for more granular control (you get both result and exception)

Example:

 CompleteFuture<Integer> future = CompleteFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) throw new RuntimeException("Oops!");
    return 100;
}).exceptionally(ex -> {
    System.out.println("Error occurred: " ex.getMessage());
    return 0; // fallback value
});

Some best practices:

• Always include error handling in production code
• Avoid silent failures — log errors at least
• Consider retry strategies or circuit breakers in critical paths

Wrapping Up

Using CompletableFuture effectively can simplify complex async workflows and improve application responsiveness. Start small — maybe just wrapping a slow database call or HTTP request. Then gradually explore chaining, combining, and advanced error handling.

It might seem overwhelming at first with so many methods ( allOf , anyOf , whenComplete , etc.), but once you understand the core patterns, it becomes second nature.

Basically that's it.

The above is the detailed content of Using Java CompletableFuture for Asynchronous Tasks. For more information, please follow other related articles on the PHP Chinese website!