Java CompletableFuture Overview: Asynchronous Programming for Java Developers

16.9.1 Overview of CompletableFuture

As Java developers, many of us are familiar with the challenges of managing asynchronous computations and concurrency. Java’s CompletableFuture is a powerful tool introduced in Java 8 that simplifies asynchronous programming by providing a more flexible and comprehensive API than traditional Future. In this section, we will explore what CompletableFuture is, its key features, and how it compares to Clojure’s core.async.

What is CompletableFuture?

CompletableFuture is part of the java.util.concurrent package and represents a future result of an asynchronous computation. It allows you to write non-blocking code by providing a way to execute tasks asynchronously and handle their results or exceptions once they complete.

Key Features of CompletableFuture

1. Asynchronous Execution: CompletableFuture allows you to run tasks asynchronously without blocking the main thread, improving application responsiveness.

2. Chaining: You can chain multiple asynchronous operations together, creating a pipeline of tasks that execute sequentially or in parallel.

3. Combining Futures: CompletableFuture provides methods to combine multiple futures, allowing you to wait for all or any of them to complete before proceeding.

4. Exception Handling: It offers robust exception handling mechanisms, enabling you to handle errors gracefully in asynchronous workflows.

5. Non-blocking API: Unlike traditional Future, CompletableFuture provides a non-blocking API, allowing you to register callbacks to be executed upon completion.

Creating and Completing CompletableFutures

Let’s start by creating a simple CompletableFuture and completing it manually:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class CompletableFutureExample {
 4    public static void main(String[] args) {
 5        // Create a CompletableFuture
 6        CompletableFuture<String> future = new CompletableFuture<>();
 7
 8        // Complete the future manually
 9        future.complete("Hello, CompletableFuture!");
10
11        // Get the result
12        future.thenAccept(result -> System.out.println(result));
13    }
14}

In this example, we create a CompletableFuture and complete it manually with a string value. The thenAccept method is used to register a callback that prints the result once the future is completed.

Running Asynchronous Tasks

CompletableFuture provides several static methods to run tasks asynchronously. The supplyAsync method is commonly used to execute a task that returns a result:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class AsyncTaskExample {
 4    public static void main(String[] args) {
 5        // Run a task asynchronously
 6        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 7            // Simulate a long-running task
 8            try {
 9                Thread.sleep(2000);
10            } catch (InterruptedException e) {
11                e.printStackTrace();
12            }
13            return "Task completed!";
14        });
15
16        // Register a callback to handle the result
17        future.thenAccept(result -> System.out.println(result));
18
19        // Keep the main thread alive to see the result
20        try {
21            Thread.sleep(3000);
22        } catch (InterruptedException e) {
23            e.printStackTrace();
24        }
25    }
26}

Here, the supplyAsync method runs a task in a separate thread, simulating a long-running operation. The thenAccept method registers a callback to print the result once the task completes.

Chaining CompletableFutures

One of the powerful features of CompletableFuture is the ability to chain multiple asynchronous operations. This is done using methods like thenApply, thenCompose, and thenCombine.

Using thenApply

The thenApply method allows you to transform the result of a future once it completes:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ChainingExample {
 4    public static void main(String[] args) {
 5        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
 6                .thenApply(greeting -> greeting + ", World!");
 7
 8        future.thenAccept(System.out::println);
 9
10        // Keep the main thread alive to see the result
11        try {
12            Thread.sleep(1000);
13        } catch (InterruptedException e) {
14            e.printStackTrace();
15        }
16    }
17}

In this example, we chain a transformation to append “, World!” to the initial result.

Using thenCompose

The thenCompose method is used to chain futures that depend on each other:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ComposeExample {
 4    public static void main(String[] args) {
 5        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
 6                .thenCompose(greeting -> CompletableFuture.supplyAsync(() -> greeting + ", World!"));
 7
 8        future.thenAccept(System.out::println);
 9
10        // Keep the main thread alive to see the result
11        try {
12            Thread.sleep(1000);
13        } catch (InterruptedException e) {
14            e.printStackTrace();
15        }
16    }
17}

Here, thenCompose is used to chain two asynchronous tasks, where the second task depends on the result of the first.

Using thenCombine

The thenCombine method allows you to combine two independent futures:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class CombineExample {
 4    public static void main(String[] args) {
 5        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
 6        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");
 7
 8        CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (greeting, name) -> greeting + ", " + name + "!");
 9
10        combinedFuture.thenAccept(System.out::println);
11
12        // Keep the main thread alive to see the result
13        try {
14            Thread.sleep(1000);
15        } catch (InterruptedException e) {
16            e.printStackTrace();
17        }
18    }
19}

In this example, thenCombine is used to combine the results of two independent futures.

Handling Exceptions

CompletableFuture provides several methods for handling exceptions, such as exceptionally, handle, and whenComplete.

Using exceptionally

The exceptionally method allows you to handle exceptions and provide a fallback result:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class ExceptionHandlingExample {
 4    public static void main(String[] args) {
 5        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 6            if (Math.random() > 0.5) {
 7                throw new RuntimeException("Something went wrong!");
 8            }
 9            return "Task completed successfully!";
10        }).exceptionally(ex -> "Fallback result due to: " + ex.getMessage());
11
12        future.thenAccept(System.out::println);
13
14        // Keep the main thread alive to see the result
15        try {
16            Thread.sleep(1000);
17        } catch (InterruptedException e) {
18            e.printStackTrace();
19        }
20    }
21}

Here, exceptionally provides a fallback result if an exception occurs during the task execution.

Using handle

The handle method allows you to handle both the result and exceptions:

 1import java.util.concurrent.CompletableFuture;
 2
 3public class HandleExample {
 4    public static void main(String[] args) {
 5        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
 6            if (Math.random() > 0.5) {
 7                throw new RuntimeException("Something went wrong!");
 8            }
 9            return "Task completed successfully!";
10        }).handle((result, ex) -> {
11            if (ex != null) {
12                return "Handled exception: " + ex.getMessage();
13            }
14            return result;
15        });
16
17        future.thenAccept(System.out::println);
18
19        // Keep the main thread alive to see the result
20        try {
21            Thread.sleep(1000);
22        } catch (InterruptedException e) {
23            e.printStackTrace();
24        }
25    }
26}

In this example, handle is used to process both the result and any exceptions that occur.

CompletableFuture vs. Clojure’s core.async

While CompletableFuture is a powerful tool for asynchronous programming in Java, Clojure offers its own approach with core.async. Let’s compare these two:

• Syntax and Style: CompletableFuture uses a fluent API style, while core.async uses channels and go blocks, which are more aligned with Clojure’s functional programming paradigm.

• Concurrency Model: CompletableFuture is based on the ForkJoinPool, whereas core.async provides a CSP (Communicating Sequential Processes) model, allowing for more complex concurrency patterns.

• Error Handling: Both provide robust error handling, but core.async allows for more granular control over error propagation through channels.

• Integration: CompletableFuture integrates seamlessly with Java’s ecosystem, while core.async is designed to work naturally within Clojure’s functional programming model.

Try It Yourself

To deepen your understanding, try modifying the examples above:

• Change the delay times in the asynchronous tasks to see how it affects the output order.
• Experiment with different exception handling strategies using handle and exceptionally.
• Combine more than two futures using thenCombine and observe the results.

Diagrams

Below is a diagram illustrating the flow of data through a series of chained CompletableFuture operations:

    graph TD;
	    A[Start] --> B[CompletableFuture.supplyAsync]
	    B --> C[thenApply]
	    C --> D[thenCompose]
	    D --> E[thenCombine]
	    E --> F[Result]

Diagram: Flow of data through chained CompletableFuture operations.

Key Takeaways

• CompletableFuture provides a flexible and powerful API for asynchronous programming in Java.
• Chaining and Combining: You can chain multiple asynchronous operations and combine futures to create complex workflows.
• Exception Handling: Robust mechanisms are available to handle exceptions gracefully.
• Comparison with Clojure: While CompletableFuture is a great tool in Java, Clojure’s core.async offers a different approach that aligns with functional programming principles.

Further Reading

• Official Java Documentation on CompletableFuture
• Clojure’s core.async Documentation
• Java Concurrency in Practice

Exercises

1. Create a CompletableFuture that performs a series of transformations on a string and handles any exceptions that occur.
2. Implement a small application that uses CompletableFuture to fetch data from multiple sources and combines the results.
3. Compare the performance of CompletableFuture with a similar implementation using core.async in Clojure.

Quiz: Mastering CompletableFuture in Java

Now that we’ve explored the power of CompletableFuture in Java, let’s delve into how Clojure’s core.async offers a unique approach to asynchronous programming, leveraging Clojure’s functional programming strengths.