CompletableFuture in Java

For building asynchronous systems, you need to attach a callback to the CompletableFuture which should automatically get called when the Future completes. But we have to be careful that supplier functions doesn’t throw checked exceptions.

In this case, the Function takes the uppercase string , and returns a CompletableFuture that converts the original string to lowercase and then appends it to upper. Forcibly causes subsequent invocations of method get()and related methods to throw the given exception, whether or not already completed. This method is designed for use only in error recovery actions, and even in such situations may result in ongoing dependent completions using established versus overwritten outcomes. Forcibly sets or resets the value subsequently returned by method get() and related methods, whether or not already completed. Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using this stage’s default asynchronous execution facility when this stage completes. Returns a new CompletionStage that, when this stage completes normally, is executed with this stage as the argument to the supplied function. First, we create a CompletableFuture that is already completed with the value “message”.

Handling Timezones in a Spring Boot Application

Waits if necessary for this future to complete, and then returns its result. Returns the result value if completed, else returns the given valueIfAbsent.

Since future2 has the least amount of sleep time, it will complete first, and the final result will be – Result of Future 2. CompletableFuture.anyOf() as the name suggests, returns a new CompletableFuture which is completed when any of the given CompletableFutures complete, with the same result. The callback function passed to thenCombine() will be called when both the Futures are complete. You don’t have the ability to attach a callback function to the Future and have it get called automatically when the Future’s result is available. A Future is used as a reference to the result of an asynchronous computation. It provides an isDone() method to check whether the computation is done or not, and a get() method to retrieve the result of the computation when it is done. Returns a string identifying this CompletableFuture, as well as its completion state.

What is CompletableFuture.thenAcceptBoth() in Java?

In this article, we will learn how to use CompletableFuture to increase the performance of our application. We’ll start with looking at the Future interface and its limitations and then will discuss how we can instead use the CompletableFuture class to overcome these limitations. The API also provides a more generic method – handle() to recover from exceptions. We explored How to create CompletableFuture, transform them, and combine multiple CompletableFutures. While thenCompose() is used to combine two Futures where one future is dependent on the other, thenCombine() is used when you want two Futures to run independently and do something after both are complete. So, the above call will block forever because the Future is never completed. Let’s say that you have 10 different Futures that you want to run in parallel and then run some function after all of them completes.

• During the time that the chef is preparing our dinner, we can do other things, like talking to friends or drinking a glass of wine and once the chef has finished the preparation, we can finally eat.
• Since this API call is time-consuming, you’re running it in a separate thread and returning a Future from your function.
• Note that all the stages below run synchronously, where a stage first converts a message string to uppercase, then a second converts the same message string to lowercase.
• The API also provides a more generic method – handle() to recover from exceptions.
• We explored How to create CompletableFuture, transform them, and combine multiple CompletableFutures.

Now we have to wait until the first API returns the result before doing anything else. If you don’t want to return anything from your callback function and just want to run some piece of code after the completion of the Future, then you can use thenAccept() and thenRun() methods. These methods are consumers and are often used as the last callback in the callback chain. Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete. If any of the given CompletableFutures complete exceptionally, then the returned CompletableFuture also does so, with a CompletionException holding this exception as its cause. Otherwise, the results, if any, of the given CompletableFutures are not reflected in the returned CompletableFuture, but may be obtained by inspecting them individually.

Applying a BiFunction on Results of Both Stages

In this section we will look at some limitations of the Future interface and how we can solve these by using theCompletableFuture class. In this article, you’ll learn how to create docker hosts using Docker machine, initialize a Swarm cluster, and deploy a multi-container app on the cluster using Docker stack. If an exception occurs, then the res argument will be null, otherwise, the ex argument will be null. Sometimes you need to execute a long-running computation and when the computation is done, you need to send its result to another long-running computation, and so on. Now, let’s say that If the remote API service is down, then you want to complete the Future manually by the last cached price of the product. For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.

• ()Waits if necessary for this future to complete, and then returns its result.
• A Future is used as a reference to the result of an asynchronous computation.
• In the above example, the anyOfFuture is completed when any of the three CompletableFutures complete.
• It just provides a get() method which blocks until the result is available to the main thread.

This method applies an uppercase conversion in an asynchronous fashion upon completion of the first stage . This example also illustrates a way to delay the asynchronous task using the delayedExecutor method. Returns a new CompletionStage that, when either this or the other given stage complete normally, executes the given action using the supplied executor. Returns a new CompletionStage that, when this and the other given stage complete normally, executes the given action using the supplied executor.

Running asynchronous computation using runAsync() –

In this section we will build a simple application that takes a list of bank transactions and calls an external service to categorize each transaction based on the description. We will simulate the call of the external service by using a method that adds some delay before returning the category of the transaction. In the next sections we will incrementally change the implementation of our client application to improve the performance by using CompletableFuture. Then we transform it to uppercase by firstly calling the get()method and right after the toUpperCase() method of the String class. Future is a Java interface that was introduced in Java 5 to represent a value that will be available in the future. The advantages of using a Future are enormous because we could do some very intensive computation asynchronously without blocking the current thread that in the meantime can do some other useful job.

Returns a new CompletionStage that, when this and the other given stage both complete normally, executes the given action. Returns a new CompletionStage that, when this stage completes normally, executes the given action using the supplied Executor. Returns a new CompletionStage that, when this stage completes normally, executes the given action. Returns the result value when complete, or throws an exception if completed exceptionally. It needs to be done manually.It allows combining multiple futures in CompletableFuture.

In earlier examples, the Supplier function passed to thenApply() callback would return a simple value but in this case, it is returning a CompletableFuture. Therefore, the final result in the above case is a nested CompletableFuture. Returns a new CompletionStage with the same result or exception as this stage, that executes the given action using the supplied Executor when this stage completes. Returns a new CompletionStage with the same result or exception as this stage, that executes the given action when this stage completes. Returns a new CompletableFuture that is asynchronously completed by a task running in the given executor with the value obtained by calling the given Supplier. ()Returns true if this CompletableFuture completed exceptionally, in any way. In case of exceptional completion with a CompletionException, methods get() and get throw an ExecutionException with the same cause as held in the corresponding CompletionException.

Since the Car instances are all independent, getting each rating asynchronously improves performance. Furthermore, waiting for all car ratings to be filled is done using a more natural allOf() method, as opposed to manual thread waiting (e.g. using Thread#join() or a CountDownLatch). This example shows how the dependent CompletableFuture that executes a Runnable triggers upon completion of both of two stages. Note that all the stages below run synchronously, where a stage first converts a message string to uppercase, then a second converts the same message string to lowercase. Very close to exceptional completion, we can cancel a computation via the cancel method from the Future interface.

Returns a new CompletionStage that, when this and the other given stage complete normally, executes the given action using this stage’s default asynchronous execution facility. When this stage is complete, the given action is invoked with the result and the exception of this stage as arguments. If the supplied action itself encounters an exception, then the returned stage exceptionally completes with this exception unless this stage also completed exceptionally. Returns a new CompletionStage that, when either this or the other given stage complete normally, is executed using the supplied executor, with the corresponding result as argument to the supplied function. Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied action. Returns a new CompletionStage that, when this and the other given stage complete normally, is executed using the supplied executor, with the two results as arguments to the supplied function. Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.