20 CompletableFuture Interview Questions and Answers

CompletableFuture is a Java class that provides a way to complete a computation asynchronously. This is done by creating a Future object and then completing it with a value or an exception. In an interview, you may be asked questions about how CompletableFuture works and how it can be used. Reviewing these questions ahead of time can help you prepare your responses and confidently earn a position.

CompletableFuture Interview Questions and Answers

Here are 20 commonly asked CompletableFuture interview questions and answers to prepare you for your interview:

1. What is CompletableFuture?

CompletableFuture is a class that is part of the Java 8 concurrency API. It allows you to create a task that can be completed in the future, and provides methods for composing and combining multiple CompletableFutures into a single task.

2. Can you explain what a completion stage is?

A completion stage is a stage of a computation that can be completed by a Future. The completion stage can be used to trigger an action upon completion of the Future, or to compose multiple Futures together.

3. How do you create a completable future in Java?

You can create a completable future in Java by using the CompletableFuture.completedFuture() method. This method takes a value as an input and returns a new CompletableFuture that is already completed with that value.

4. Does creating an instance of CompletableFuture automatically start its execution? If not, then how can it be started?

No, creating an instance of CompletableFuture does not automatically start its execution. In order to start its execution, you must call the .run() or .start() method on the CompletableFuture instance.

5. Can you give me some examples of the types of tasks that are commonly executed asynchronously with CompletableFuture?

CompletableFuture is often used for tasks that are long-running or computationally intensive, as executing them asynchronously can improve performance by freeing up resources to work on other tasks. Some examples of tasks that are commonly executed asynchronously with CompletableFuture include tasks that involve network or disk I/O, tasks that perform heavy computations, and tasks that execute long-running database queries.

6. Is there any limit to the number of asynchronous tasks that can run concurrently using CompletableFuture?

There is no limit to the number of asynchronous tasks that can run concurrently using CompletableFuture.

7. Can you explain what a dependent stage is and how it relates to CompletableFutures?

A dependent stage is a CompletableFuture that is created based on the completion of another CompletableFuture. In other words, the dependent stage will not begin until the original CompletableFuture has completed. This is useful for creating chains of CompletableFutures, where each subsequent stage is dependent on the previous one.

8. What is your understanding of the complete() method and how does it differ from the get() method?

The complete() method is used to complete a Future object, which is generally used to indicate that the associated task is finished. The get() method, on the other hand, is used to retrieve the result of a Future object. If the Future object has not yet been completed, then the get() method will block until it is.

9. What happens if an error occurs while performing one of the stages of CompletableFuture? Will it stop all other ongoing computations or will they continue running parallel to each other?

If an error occurs while performing one of the stages of CompletableFuture, it will not stop all other ongoing computations. The other computations will continue running parallel to each other.

10. Can you explain what “Completion Stage” means in the context of CompletableFuture?

A completion stage is a stage of a computation that can be completed by a Future. The completion stage can be thought of as a promise that the Future will be completed at some point in the future.

11. Can you explain the difference between synchronous and asynchronous calls? When would you use a synchronous call over an asynchronous call?

A synchronous call is one where the caller waits for the called method to complete before continuing. An asynchronous call is one where the caller does not wait for the called method to complete before continuing. You would use a synchronous call when you need the results of the called method in order to continue, and you would use an asynchronous call when you don’t need the results of the called method in order to continue.

12. Can you explain the difference between blocking and non-blocking calls? Which type of call do you prefer to use? Why?

Blocking calls are those where the thread making the call will wait until the call returns before continuing. Non-blocking calls, on the other hand, allow the thread to continue executing while the call is being processed. I prefer to use non-blocking calls whenever possible, as they can help to improve performance by allowing the thread to continue working on other tasks while waiting for the results of the call.

13. Do you think it’s possible to chain multiple asynchronous operations so that one operation starts only after another has completed? If yes, then can you describe how this could be done?

Yes, it is possible to chain multiple asynchronous operations so that one operation starts only after another has completed. This can be done by using the CompletableFuture.thenCompose() method. This method takes a function as an argument, and the function is executed after the previous operation has completed. The function can then return a new CompletableFuture, which will be executed asynchronously.

14. Can you explain the three modes of failure handling provided by CompletableFuture?

The three modes of failure handling are:

1. Complete the future with the exception
2. Complete the future with a value
3. Propagate the exception to the caller

15. What is the best way to check for empty values when working with CompletableFutures?

You can use the isDone() method to check if a CompletableFuture is empty.

16. Can you explain what a “fork/join pool” is and how it connects to CompletableFuture?

A fork/join pool is a type of ExecutorService that is designed to efficiently run fork/join style tasks. When a CompletableFuture is created, it is automatically associated with a fork/join pool, and all of its asynchronous operations will be executed in that pool.

17. Can you explain the difference between supplyAsync() and runAsync() ?

The main difference between supplyAsync() and runAsync() is that supplyAsync() returns a CompletableFuture, whereas runAsync() does not. This means that you can chain additional actions onto a supplyAsync() call, but you cannot do so with a runAsync() call. Additionally, supplyAsync() takes in a Supplier, which is a function that does not take in any arguments and returns a value, whereas runAsync() takes in a Runnable, which is a function that does not take in any arguments and does not return a value.

18. What is the difference between invokeAny() and invokeAll() methods?

The invokeAny() method will execute the given tasks, returning the result of one that has completed successfully (i.e., without throwing an exception), if any do. The invokeAll() method, on the other hand, will execute all of the given tasks and return a list of Future objects that can be used to track the status of each task and retrieve their results.

19. Are there any drawbacks to using CompletableFuture?

While CompletableFuture does offer a number of advantages, there are also a few potential drawbacks to keep in mind. One is that CompletableFuture is not well suited for tasks that need to be run in a specific order. Additionally, CompletableFuture can be more difficult to debug than other types of asynchronous tasks.

20. What are some real world scenarios where CompletableFuture should be used over normal threads?

CompletableFuture should be used in any scenario where you want to be able to chain together multiple actions that will be executed asynchronously. This is especially useful in cases where you need to perform multiple actions in parallel and then wait for all of them to finish before moving on to the next step.