{"id":6137,"date":"2023-11-01T17:56:36","date_gmt":"2023-11-02T00:56:36","guid":{"rendered":"https:\/\/ioflood.com\/blog\/?p=6137"},"modified":"2024-03-05T15:47:22","modified_gmt":"2024-03-05T22:47:22","slug":"completablefuture-java","status":"publish","type":"post","link":"https:\/\/ioflood.com\/blog\/completablefuture-java\/","title":{"rendered":"CompletableFuture Java: Handling Asynchronous Tasks"},"content":{"rendered":"
\n
\"completablefuture_java_future_clock_message\"<\/figure>\n<\/div>\n

Are you finding it challenging to manage asynchronous tasks in Java? You’re not alone. Many developers grapple with this task, but there’s a tool that can make this process a breeze.<\/p>\n

Like a skilled orchestra conductor, CompletableFuture in Java is a handy utility that can seamlessly coordinate multiple threads. These threads can run on any system, even those without Java installed.<\/p>\n

This guide will walk you through the process of using CompletableFuture in Java<\/strong>, from the basics to more advanced techniques. We’ll cover everything from creating a CompletableFuture, attaching a callback, handling exceptions, to combining multiple CompletableFutures and running them in parallel.<\/p>\n

So, let’s dive in and start mastering CompletableFuture in Java!<\/p>\n

TL;DR: How Do I Use CompletableFuture in Java?<\/h2>\n

\n CompletableFuture is a class in Java that allows you to write asynchronous, non-blocking code, instantiated with the syntax: CompletableFuture<String> future = CompletableFuture.supplyAsync();<\/code>. It’s a powerful tool that can help you manage multiple threads with ease.\n<\/p><\/blockquote>\n

Here’s a simple example:<\/p>\n

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello World\");\nfuture.thenAccept(System.out::println);\n\n# Output:\n# 'Hello World'\n<\/code><\/pre>\n
In this example, we create a CompletableFuture that runs a simple task asynchronously – it supplies the string ‘Hello World’. The thenAccept<\/code> method is then used to consume the result of the computation when it’s ready, without blocking the execution thread. In this case, it simply prints the result.<\/p>\n
\n  This is a basic way to use CompletableFuture in Java, but there’s much more to learn about managing asynchronous tasks effectively. Continue reading for a more detailed explanation and advanced usage examples.\n<\/p><\/blockquote>\n
Creating and Using CompletableFuture in Java<\/h2>\n
In Java, creating a CompletableFuture is straightforward. Here’s a basic example:<\/p>\n
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello CompletableFuture\");\n<\/code><\/pre>\n
In this example, CompletableFuture.supplyAsync()<\/code> is used to create a CompletableFuture that asynchronously executes the provided Supplier function, which in this case, simply returns the string ‘Hello CompletableFuture’.<\/p>\n
Attaching Callbacks: thenApply, thenAccept, and thenRun<\/h3>\n
Once you’ve created a CompletableFuture, you can attach callbacks using the thenApply<\/code>, thenAccept<\/code>, and thenRun<\/code> methods. These methods are used to handle the result of the computation once it’s ready.<\/p>\n
Here’s how you can use these methods:<\/p>\n
future.thenApply(result -> result.toUpperCase())\n      .thenAccept(result -> System.out.println(\"Result: \" + result))\n      .thenRun(() -> System.out.println(\"Operation Completed.\"));\n\n# Output:\n# 'Result: HELLO COMPLETABLEFUTURE'\n# 'Operation Completed.'\n<\/code><\/pre>\n
In this example, thenApply<\/code> is used to transform the result to uppercase. thenAccept<\/code> is then used to consume the result, in this case, by printing it. Finally, thenRun<\/code> is used to execute a Runnable once the computation is done. It doesn’t consume the result; instead, it simply performs an action.<\/p>\n
Handling Exceptions<\/h3>\n
Just like any other operation in Java, CompletableFuture operations can throw exceptions. Here’s how you can handle them:<\/p>\n
future.exceptionally(ex -> \"An error occurred: \" + ex.getMessage())\n      .thenAccept(System.out::println);\n<\/code><\/pre>\n
In this example, exceptionally<\/code> is used to handle any exceptions that might occur during the execution of the CompletableFuture. If an exception occurs, it returns a default value and prints an error message.<\/p>\n
Combining CompletableFutures: thenCompose and thenCombine<\/h2>\n
In Java, you can combine multiple CompletableFutures using thenCompose<\/code> and thenCombine<\/code> methods.<\/p>\n
The thenCompose<\/code> method is used when a CompletableFuture’s result is dependent on another CompletableFuture. Here’s an example:<\/p>\n
CompletableFuture<String> firstTask = CompletableFuture.supplyAsync(() -> \"Hello\");\nCompletableFuture<String> secondTask = firstTask.thenCompose(result -> CompletableFuture.supplyAsync(() -> result + \" CompletableFuture\"));\nsecondTask.thenAccept(System.out::println);\n\n# Output:\n# 'Hello CompletableFuture'\n<\/code><\/pre>\n
In this example, secondTask<\/code> is dependent on firstTask<\/code>. The thenCompose<\/code> method is used to chain these tasks together, so secondTask<\/code> won’t start until firstTask<\/code> is completed.<\/p>\n
On the other hand, thenCombine<\/code> is used when you want to combine two independent CompletableFutures. Here’s an example:<\/p>\n
CompletableFuture<String> firstTask = CompletableFuture.supplyAsync(() -> \"Hello\");\nCompletableFuture<String> secondTask = CompletableFuture.supplyAsync(() -> \" CompletableFuture\");\nCompletableFuture<String> combinedTask = firstTask.thenCombine(secondTask, (firstResult, secondResult) -> firstResult + secondResult);\ncombinedTask.thenAccept(System.out::println);\n\n# Output:\n# 'Hello CompletableFuture'\n<\/code><\/pre>\n
In this example, firstTask<\/code> and secondTask<\/code> are independent of each other. The thenCombine<\/code> method is used to combine their results once both are completed.<\/p>\n
Running Multiple CompletableFutures in Parallel<\/h2>\n
In a real-world scenario, you might need to run multiple CompletableFutures in parallel. Here’s how you can do it:<\/p>\n
CompletableFuture<String> firstTask = CompletableFuture.supplyAsync(() -> \"Task 1\");\nCompletableFuture<String> secondTask = CompletableFuture.supplyAsync(() -> \"Task 2\");\nCompletableFuture<Void> combinedTask = CompletableFuture.allOf(firstTask, secondTask);\n\nfirstTask.thenAccept(result -> System.out.println(result + \" completed.\"));\nsecondTask.thenAccept(result -> System.out.println(result + \" completed.\"));\ncombinedTask.thenRun(() -> System.out.println(\"All tasks completed.\"));\n\n# Output:\n# 'Task 1 completed.'\n# 'Task 2 completed.'\n# 'All tasks completed.'\n<\/code><\/pre>\n
In this example, CompletableFuture.allOf()<\/code> is used to create a CompletableFuture that is completed only when both firstTask<\/code> and secondTask<\/code> are completed. This allows you to run multiple CompletableFutures in parallel.<\/p>\n
Alternatives to CompletableFuture in Java<\/h2>\n
While CompletableFuture is a powerful tool for handling asynchronous tasks, it’s not the only way to manage them in Java. Two other key approaches include using the Future interface and the ExecutorService class.<\/p>\n
Exploring the Future Interface<\/h3>\n
The Future interface has been around since Java 5 and provides a way to handle asynchronous tasks but lacks some of the powerful features of CompletableFuture. Here’s a simple example of how it’s used:<\/p>\n
ExecutorService executorService = Executors.newSingleThreadExecutor();\nFuture<String> future = executorService.submit(() -> \"Hello Future\");\nexecutorService.shutdown();\n\ntry {\n    System.out.println(future.get());\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# 'Hello Future'\n<\/code><\/pre>\n
In this example, we create an ExecutorService and submit a Callable to it. The submit<\/code> method returns a Future, which we can use to retrieve the result of the computation once it’s ready. However, the get<\/code> method blocks until the computation is done, which is one of the limitations of the Future interface.<\/p>\n
Leveraging the ExecutorService Class<\/h3>\n
The ExecutorService class is another way to handle asynchronous tasks in Java. It provides methods to manage and control thread execution in concurrent Java applications.<\/p>\n
Here’s an example of how to use it:<\/p>\n
ExecutorService executorService = Executors.newFixedThreadPool(2);\nFuture<String> future1 = executorService.submit(() -> \"Task 1\");\nFuture<String> future2 = executorService.submit(() -> \"Task 2\");\nexecutorService.shutdown();\n\ntry {\n    System.out.println(future1.get() + \" completed.\");\n    System.out.println(future2.get() + \" completed.\");\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# 'Task 1 completed.'\n# 'Task 2 completed.'\n<\/code><\/pre>\n
In this example, we create an ExecutorService with a fixed thread pool. We then submit two tasks to it, each returning a Future. We can use these Futures to retrieve the results of the computations once they’re done.<\/p>\n
While ExecutorService provides more control over thread execution compared to the Future interface, it still lacks the ability to chain and combine Futures, which is one of the strengths of CompletableFuture.<\/p>\n
Making the Right Choice<\/h3>\n
Choosing between CompletableFuture, Future, and ExecutorService depends on your specific needs. If you need to chain and combine Futures or want to leverage functional-style operations, CompletableFuture is the way to go. If you need more control over thread execution, consider using ExecutorService. If your needs are simple and you don’t mind blocking for results, the Future interface might be sufficient.<\/p>\n
Troubleshooting CompletableFuture in Java<\/h2>\n
Like any tool, CompletableFuture comes with its own set of potential issues and considerations. Let’s explore some common challenges and their solutions.<\/p>\n
Handling Exceptions<\/h3>\n
One common issue with CompletableFuture is dealing with exceptions. Unchecked exceptions thrown during the computation are wrapped in an ExecutionException<\/code> and thrown when you call get()<\/code>. Here’s an example:<\/p>\n
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {\n    throw new RuntimeException(\"Exception during computation\");\n    return \"Hello CompletableFuture\";\n});\n\ntry {\n    System.out.println(future.get());\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# java.util.concurrent.ExecutionException: java.lang.RuntimeException: Exception during computation\n<\/code><\/pre>\n
In this example, an unchecked exception is thrown during the computation. When we call get()<\/code>, this exception is wrapped in an ExecutionException<\/code> and rethrown.<\/p>\n
To handle this, you can use the exceptionally<\/code> method, as we discussed in the ‘Basic Use’ section.<\/p>\n
Dealing with Blocking Code<\/h3>\n
Another common issue is dealing with blocking code. If you’re not careful, you can end up blocking the execution thread while waiting for a CompletableFuture to complete. Here’s an example:<\/p>\n
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello CompletableFuture\");\n\ntry {\n    System.out.println(future.get());\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# 'Hello CompletableFuture'\n<\/code><\/pre>\n
In this example, the get()<\/code> method blocks the execution thread until the CompletableFuture is completed. To avoid this, you can use the thenApply<\/code>, thenAccept<\/code>, or thenRun<\/code> methods to attach a callback to the CompletableFuture, as we discussed in the ‘Basic Use’ section.<\/p>\n
Managing Thread Pools<\/h3>\n
Finally, managing thread pools can be a challenge when using CompletableFuture. By default, CompletableFuture uses the ForkJoinPool.commonPool()<\/code>, but you can specify a custom Executor if you need more control over the thread pool. Here’s an example:<\/p>\n
ExecutorService executorService = Executors.newFixedThreadPool(2);\nCompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello CompletableFuture\", executorService);\nexecutorService.shutdown();\n\ntry {\n    System.out.println(future.get());\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# 'Hello CompletableFuture'\n<\/code><\/pre>\n
In this example, we create a custom ExecutorService with a fixed thread pool and pass it to supplyAsync()<\/code>. This allows us to control the thread pool used by the CompletableFuture.<\/p>\n
Understanding Asynchronous Programming in Java<\/h2>\n
Asynchronous programming is a design pattern that allows multiple tasks to be executed concurrently, improving the performance of your application. In Java, this is achieved through the use of threads. A thread is a separate path of execution, allowing multiple tasks to be performed at the same time.<\/p>\n
The Role of the Future Interface<\/h3>\n
In Java, the Future interface plays a crucial role in asynchronous programming. It represents the result of an asynchronous computation and provides methods to check if the computation is complete, to wait for its completion, and to retrieve the result of the computation.<\/p>\n
Here’s a simple example:<\/p>\n
ExecutorService executorService = Executors.newSingleThreadExecutor();\nFuture<String> future = executorService.submit(() -> \"Hello Future\");\nexecutorService.shutdown();\n\ntry {\n    System.out.println(future.get());\n} catch (InterruptedException | ExecutionException e) {\n    e.printStackTrace();\n}\n\n# Output:\n# 'Hello Future'\n<\/code><\/pre>\n
In this example, we submit a Callable to an ExecutorService, which returns a Future. We can then use the get()<\/code> method to retrieve the result of the computation, blocking if necessary until it is ready.<\/p>\n
The CompletionStage Interface and CompletableFuture<\/h3>\n
The CompletionStage interface, introduced in Java 8, is a step up from Future. It represents a stage of a possibly asynchronous computation, that performs an action when the computation is complete.<\/p>\n
CompletableFuture is a class that implements both the Future interface and the CompletionStage interface. It provides a large number of methods for creating, chaining, and combining multiple stages, making it a powerful tool for handling asynchronous tasks in Java.<\/p>\n
Here’s a simple example of how CompletableFuture can be used:<\/p>\n
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> \"Hello CompletableFuture\");\nfuture.thenAccept(System.out::println);\n\n# Output:\n# 'Hello CompletableFuture'\n<\/code><\/pre>\n
In this example, CompletableFuture.supplyAsync()<\/code> is used to create a CompletableFuture that runs a task asynchronously. The thenAccept()<\/code> method is then used to consume the result of the computation when it’s ready, without blocking the execution thread.<\/p>\n
CompletableFuture in Real-World Applications<\/h2>\n
CompletableFuture is not just a theoretical concept, it’s a practical tool that can be used in various real-world applications. Let’s explore some of them.<\/p>\n
CompletableFuture in Web Programming<\/h3>\n
In web programming, CompletableFuture can be used to handle asynchronous tasks, such as making multiple HTTP requests simultaneously. This can significantly improve the performance of your web application by reducing the waiting time for IO operations.<\/p>\n
CompletableFuture<HttpResponse<String>> future1 = HttpClient.newHttpClient().sendAsync(HttpRequest.newBuilder(URI.create(\"http:\/\/example.com\")).build(), HttpResponse.BodyHandlers.ofString());\nCompletableFuture<HttpResponse<String>> future2 = HttpClient.newHttpClient().sendAsync(HttpRequest.newBuilder(URI.create(\"http:\/\/example.org\")).build(), HttpResponse.BodyHandlers.ofString());\n\nCompletableFuture.allOf(future1, future2).join();\n\n# Output:\n# [The responses from the HTTP requests]\n<\/code><\/pre>\n
In this example, we use CompletableFuture.allOf()<\/code> to make two HTTP requests simultaneously. Once both requests are completed, the responses are available for further processing.<\/p>\n
CompletableFuture for Database Access<\/h3>\n
Similarly, CompletableFuture can be used to handle asynchronous database operations. This can be particularly useful when you need to perform multiple database operations that don’t depend on each other.<\/p>\n
CompletableFuture<ResultSet> future1 = CompletableFuture.supplyAsync(() -> database.query(\"SELECT * FROM table1\"));\nCompletableFuture<ResultSet> future2 = CompletableFuture.supplyAsync(() -> database.query(\"SELECT * FROM table2\"));\n\nCompletableFuture.allOf(future1, future2).join();\n\n# Output:\n# [The results of the database queries]\n<\/code><\/pre>\n
In this example, we use CompletableFuture.allOf()<\/code> to perform two database queries simultaneously. Once both queries are completed, the results are available for further processing.<\/p>\n
CompletableFuture in Multi-Threaded Applications<\/h3>\n
In multi-threaded applications, CompletableFuture can be used to manage and coordinate multiple threads. This can help you create more efficient and responsive applications.<\/p>\n
CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> System.out.println(\"Hello from Thread 1\"));\nCompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> System.out.println(\"Hello from Thread 2\"));\n\nCompletableFuture.allOf(future1, future2).join();\n\n# Output:\n# 'Hello from Thread 1'\n# 'Hello from Thread 2'\n<\/code><\/pre>\n
In this example, we use CompletableFuture.runAsync()<\/code> to run two tasks on separate threads. With CompletableFuture.allOf()<\/code>, we wait for both tasks to complete.<\/p>\n
Further Resources for CompletableFuture<\/h3>\n
If you want to learn more about CompletableFuture and related topics, here are some resources you might find helpful:<\/p>\n