CompletableFuture: Mastering Asynchronous Programming in Java

What is CompletableFuture?

CompletableFuture is a powerful tool in the Java programming language, specifically designed for handling asynchronous operations. It extends the capabilities of the traditional Future interface by allowing developers to write non-blocking code that can easily manage tasks that complete in the future.

One of the primary advantages of CompletableFuture is its ability to facilitate complex workflows where multiple tasks can be executed in parallel or sequentially. It provides a rich set of methods to combine, transform, and chain tasks, resulting in more readable and maintainable code.

In contrast to its predecessor, CompletableFuture allows for a more fluent and functional programming style. This enhances code clarity and reduces boilerplate, making it easier for developers to focus on business logic rather than complex threading concerns.

CompletableFuture also includes built-in mechanisms for handling exceptions. This enables more robust application development as it simplifies error handling in asynchronous operations. When an error occurs, developers can respond to it in a more controlled manner, thus improving the overall reliability of their applications.

Overall, CompletableFuture represents a significant advancement in Java's approach to concurrency. It empowers developers to write efficient, responsive, and non-blocking applications while effectively managing complex asynchronous tasks.

Key Features of CompletableFuture

CompletableFuture offers a robust framework for handling asynchronous operations. Its extensive features enable developers to create non-blocking applications that are easier to compose and manage. Below are the key features that define the capabilities of CompletableFuture.

Asynchronous Execution

A standout feature of CompletableFuture is its ability to execute tasks asynchronously. This ensures that the main thread remains responsive while background tasks run independently. This non-blocking approach enhances application performance, especially in environments requiring high concurrency.

Task Composition

Task composition allows developers to chain multiple asynchronous operations in a readable and efficient manner. This feature streamlines complex workflows and fosters clearer code structure. CompletableFuture provides several methods for task composition:

• thenApply()This method is used to transform the result of a CompletableFuture once it completes successfully. It takes a function as an argument, processes the result of the preceding stage, and returns a new CompletableFuture.
• thenCompose()thenCompose() allows for chaining multiple asynchronous tasks where the next task depends on the result of the previous one. It requires a function that returns another CompletableFuture, creating a seamless flow between tasks.
• thenCombine()With thenCombine(), two independent CompletableFutures can be executed concurrently. Once both tasks are complete, their results are combined using a specified function. This is particularly useful for merging results from different sources.
• allOf()allOf() allows multiple CompletableFutures to run in parallel. It returns a new CompletableFuture that completes when all the provided futures complete. This is useful for executing multiple tasks concurrently and waiting for their completion.

Exception Handling

CompletableFuture simplifies error handling in asynchronous programming. It provides methods that allow developers to manage exceptions in a more declarative manner, improving code clarity and flow control. Key exception handling methods include:

• exceptionally()exceptionally() provides a way to recover from errors that occur during the execution of a CompletableFuture. It allows the developer to specify a fallback value or action in the event of an exception, ensuring graceful handling of errors.
• handle()handle() enables processing of both the result and any exceptions in a single callback. This method provides a way to transform the result or take an alternative action based on whether the CompletableFuture completed exceptionally or normally.

Cancellation and Completion

CompletableFuture gives developers control over the completion and cancellation of tasks. It includes methods to manage task states effectively, enhancing flexibility in handling long-running operations.

• cancel()The cancel() method allows for the termination of a running task. It provides the option to either interrupt the thread executing the task or simply mark it as cancelled.
• complete()complete() allows developers to manually complete a CompletableFuture with a specific value, regardless of its current state. This can be useful in scenarios where external conditions dictate the completion of a task.
• completeExceptionally()completeExceptionally() is used to finish a CompletableFuture with an exception. This method allows developers to signal that a failure has occurred in an operation, providing a mechanism to inform other parts of the application of the failure.

Creating a CompletableFuture

Creating a CompletableFuture involves utilizing various methods that facilitate asynchronous task execution. This section covers the fundamental ways to instantiate a CompletableFuture.

supplyAsync()

The supplyAsync() method is essential for starting a new CompletableFuture in a non-blocking manner. It allows developers to supply a computation that runs asynchronously, returning a result or completing exceptionally.

This method takes a Supplier functional interface, which can be implemented using a lambda expression or a method reference. Here’s a simple example:

• CompletableFuture future = CompletableFuture.supplyAsync(() -> { // Simulate a long-running task return "Result from async task!"; });

This code initiates a background task that returns a string result. While the task is running, the main thread is free to perform other operations.

Using ForkJoinPool.commonPool()

By default, when using supplyAsync(), the task is executed in the ForkJoinPool.commonPool(). This pool is a shared resource among all tasks that invoke supplyAsync(). Using this common pool allows for simple and efficient resource management without the need to create custom executors for every task.

The common pool is well-suited for smaller tasks that are lightweight, leveraging the available threads efficiently and providing optimal resource utilization.

Specifying a Custom Executor

In situations where control over the thread management is necessary, such as highly intensive tasks or managing thread lifecycles, it's possible to specify a custom executor.

By passing an instance of Executor to the supplyAsync() method, the developer can dictate where the task runs. This flexibility allows for more complex thread management strategies. Here is an example:

• ExecutorService executor = Executors.newFixedThreadPool(4);
• CompletableFuture future = CompletableFuture.supplyAsync(() -> { return "Result using custom executor!"; }, executor);

In this example, a fixed thread pool of size four is created, allowing multiple tasks to run concurrently without overloading the system’s resources.

Specifying a custom executor is especially beneficial for applications that require fine-tuned performance or need to comply with specific threading policies.

CompletableFuture Methods Overview

This section provides an in-depth look at the various methods available in the CompletableFuture class, which are essential for handling asynchronous tasks effectively. Each method serves a specific purpose, enabling developers to manage the flow and control of data when working with future results.

thenAccept()

The thenAccept() method is a key feature that allows you to specify an action that will be executed once the CompletableFuture completes successfully. This method accepts a consumer as an argument, which takes the result of the CompletableFuture as an input but does not return any value. It is particularly useful for side effects, such as logging or updating user interfaces.

Example usage of thenAccept() can look like this:

CompletableFuture.supplyAsync(() -> "Hello, World!") .thenAccept(result -> System.out.println("Result: " + result));

In this example, the string "Hello, World!" is generated asynchronously, and once the computation is finished, the result is printed to the console.

thenRun()

The thenRun() method allows you to execute a Runnable action after the CompletableFuture completes, similar to thenAccept(). However, unlike thenAccept(), it does not take any result from the CompletableFuture. This method is useful for performing actions that do not depend on the result of the previous computation.

A simple example would be:

CompletableFuture.supplyAsync(() -> "Task Complete") .thenRun(() -> System.out.println("Next task starts now."));

Here, the message "Task Complete" is generated, and after that, "Next task starts now." is printed once the first task completes.

thenCombine()

The thenCombine() method is particularly powerful as it enables the combination of the results of two CompletableFutures. It takes two CompletableFutures and a BiFunction that merges their results once both futures are completed. This is helpful when there is a need to aggregate results from two independent asynchronous computations.

Here's how it can be applied:

CompletableFuture future1 = CompletableFuture.supplyAsync(() -> 10); CompletableFuture future2 = CompletableFuture.supplyAsync(() -> 20); future1.thenCombine(future2, (result1, result2) -> result1 + result2) .thenAccept(finalResult -> System.out.println("Combined Result: " + finalResult));

This example combines results from two separate tasks and prints the combined value, demonstrating the ability to synchronize between the two futures.

thenCompose()

The thenCompose() method is essential for chaining asynchronous computations that depend on the result of a previous CompletableFuture. This method takes a Function that returns a new CompletableFuture, allowing for a more fluid way to manage dependent asynchronous tasks.

An example of using thenCompose() is:

CompletableFuture future = CompletableFuture.supplyAsync(() -> 5) .thenCompose(result -> CompletableFuture.supplyAsync(() -> result * 2)); future.thenAccept(result -> System.out.println("Final Result: " + result));

In this case, an initial value is doubled asynchronously, showcasing how thenCompose() can facilitate chaining while keeping the code clean and straightforward.

Example: Simple Asynchronous Operation

This section presents a straightforward example of using CompletableFuture to perform an asynchronous operation. The following subsections detail the use of Thread.sleep() to mimic a long-running task and illustrate how to return a string value upon completion.

Using Thread.sleep()

In Java, simulating a delay in execution can be achieved by utilizing the Thread.sleep() method. This method pauses the current thread for a specified period, allowing developers to mimic operations that take time, such as network calls or long computations. When used in conjunction with CompletableFuture, this feature allows tasks to run asynchronously without blocking the execution of other operations.

Here is an example of how to use Thread.sleep() within a CompletableFuture:

CompletableFuture future = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(5000); // Simulating a long task } catch (InterruptedException e) { throw new IllegalStateException(e); } return "Hello, world!"; });

In this snippet, the CompletableFuture is created to execute a task that sleeps for five seconds. This example serves to demonstrate the asynchronous nature of CompletableFuture, allowing other operations to progress while waiting for the result of this long-running task.

Returning a String Value

After the asynchronous task completes, it is crucial to handle the results appropriately. CompletableFuture provides various methods that enable consumers to work with the outcome of the asynchronous operation. In the example above, the return value is a string, and further processing can be utilized to handle this result.

Once the asynchronous task is finished, developers can use thenAccept() to define actions that should occur with the result. Here’s how that can be implemented:

future.thenAccept(result -> { System.out.println(result); // Prints the result after the task is complete });

This example demonstrates the power of CompletableFuture in managing the flow of data once the operation has concluded. When the CompletableFuture is complete, it will print "Hello, world!" to the console, showcasing effective handling of the result obtained from an asynchronous operation.

Chaining Asynchronous Tasks

Chaining asynchronous tasks allows developers to create a series of dependent operations that execute in sequence. This approach enhances the flow of data between tasks and ensures that results can be efficiently passed from one task to the next.

thenApplyAsync()

The thenApplyAsync() method is used to transform the result of a completed CompletableFuture into another value. This method is executed asynchronously, meaning the transformation occurs in a separate thread from the one that completed the previous task. This non-blocking behavior is crucial for maintaining application responsiveness.

• When using thenApplyAsync(), a function is provided that takes the original result and produces a new result. It ensures that the transformation is handled in the background, optimizing performance.
• This method can be especially useful in scenarios where a significant amount of processing is required after an initial task is completed.

Multiplying Values

Consider a scenario where an initial CompletableFuture retrieves a numeric value, and there’s a requirement to multiply this value by a constant. Using thenApplyAsync(), the multiplication can be performed asynchronously:

```java CompletableFuture future = CompletableFuture.supplyAsync(() -> 10) .thenApplyAsync(result -> result * 2); ```

In this example, the original value of `10` is multiplied by `2`, resulting in `20`. This transformation occurs without blocking the main thread, showcasing the benefits of asynchronous processing.

Adding Values

Building on the previous example, suppose there’s an additional requirement to add a specific number after the multiplication. The chaining structure allows this operation to be seamlessly integrated:

```java CompletableFuture future = CompletableFuture.supplyAsync(() -> 10) .thenApplyAsync(result -> result * 2) .thenApplyAsync(result -> result + 5); ```

Here, after multiplying by `2`, a `5` is added to the result, yielding a final value of `25`. Each step of the process is handled asynchronously, which supports a fluid workflow while maintaining system responsiveness.

Error Handling in CompletableFuture

Error handling is an essential part of working with CompletableFuture. It allows developers to manage exceptions effectively without causing the entire application to fail. Here's a closer look at how to handle errors in this asynchronous programming model.

Handling ArithmeticException

Arithmetic exceptions are common in programming, particularly when performing mathematical operations. In the context of CompletableFuture, such exceptions can arise when calculations are attempted that are mathematically invalid, like division by zero. Handling these exceptions is crucial to ensure that the application remains stable.

Using the exceptionally() method provides a straightforward way to manage such exceptions. This method takes a function that will be executed if the CompletableFuture completes exceptionally. The implementation demonstrates this by capturing ArithmeticException and allowing the program to continue running without failures.

• Example of exception handling:Here’s a code snippet illustrating how to handle an ArithmeticException: CompletableFuture future = CompletableFuture.supplyAsync(() -> { if (true) throw new ArithmeticException("Error: Division by zero"); return 1; }).exceptionally(ex -> { System.out.println("Exception occurred: " + ex.getMessage()); return 0; // Default value }); The above code checks for an error condition, raises an exception, and allows the exceptionally method to deal with it. A default value is returned, ensuring that subsequent operations can proceed without interruptions.

Setting Default Values

When an exception is encountered, it is beneficial to return a default value that allows the program to maintain continuity in execution. Setting default values serves as a fallback mechanism whenever an operation fails. This technique avoids the cascading effect of errors that could crash the entire application.

Using exceptionally(), it’s possible to not only log the exception but also to dictate what value should be returned on error. In this way, developers can maintain control over the program flow and ensure a smoother user experience.

• Considerations for setting default values:Utilizing placeholders for computation: CompletableFuture futureWithDefaultValue = CompletableFuture.supplyAsync(() -> { throw new RuntimeException("An error occurred."); }).exceptionally(ex -> { return -1; // Use -1 as a default value }); This approach demonstrates how a default value (like -1) can be established in case of an error, enabling other areas of the application to function without interruption.

Running Multiple Tasks in Parallel

Executing tasks in parallel is essential for improving application performance and responsiveness. By leveraging the capabilities of CompletableFuture, developers can efficiently manage multiple tasks that run simultaneously, making optimal use of system resources.

Using allOf()

The method allOf() is a powerful feature that allows developers to wait for multiple CompletableFutures to complete before proceeding. This is especially useful when there are multiple independent tasks that can run concurrently without dependency on each other. The result is a single CompletableFuture that completes when all the provided CompletableFutures are done.

Here’s how allOf() can be utilized:

• It takes an array of CompletableFuture instances as input.
• Returns a CompletableFuture that completes when all supplied futures complete.
• Provides a convenient way to synchronize multiple tasks without manual management of their completion states.

Accessing Results of Parallel Tasks

When multiple tasks are executed in parallel, accessing the results becomes crucial. After using allOf(), the results of each task can be retrieved seamlessly. Here’s how to do it:

• Each individual CompletableFuture must be separately defined for collecting results.
• After calling allOf(), the results can be fetched using the get() method.
• Proper exception handling must be implemented when accessing results to manage any task failures.

For instance, assume three separate tasks are running in parallel to fetch data from different sources. Once all tasks are completed, their results can be processed:

• Each task is executed independently, and allOf() ensures that the main flow waits until all tasks are finished.
• After completion, results can be logged, combined, or processed based on application requirements.

This approach not only optimizes performance but also enhances the responsiveness of applications dealing with multiple concurrent operations.

Completing a CompletableFuture involves controlling how and when the asynchronous task's result is available. This feature provides flexibility in handling the lifecycle of the task.

Completing a CompletableFuture

complete()

The complete() method is used to manually complete a CompletableFuture with a given value. This is particularly useful when the outcome of an asynchronous operation is determined by an external event or condition, rather than solely by the execution of the task itself.

By invoking complete(), developers can set the result of the CompletableFuture without waiting for the asynchronous computation to finish. This operation marks the CompletableFuture as completed, allowing any dependent actions to execute immediately. Here's a brief overview of the process:

• Invoke complete(value): Passing a value to this method will complete the future with that value, notifying any consumers waiting for the completion.
• Execute dependent actions: Any tasks that are chained to this CompletableFuture through methods like thenApply() or thenAccept() will execute with the provided value.

This method also handles scenarios where the CompletableFuture needs to be completed based on external triggers, enhancing its applicability in real-world scenarios.

completeExceptionally()

The completeExceptionally() method provides a means to complete the CompletableFuture with an exception. This is advantageous for indicating failure in asynchronous tasks. When this method is invoked, all attached handlers that depend on the result will be triggered with the specified exception, allowing for a structured error handling approach.

Utilizing completeExceptionally() involves a few key steps:

• Invoke completeExceptionally(exception): By passing an exception to this method, the CompletableFuture will transition to a completed state with the exception set as the cause. This prompts any waiting consumers to handle the failure appropriately.
• Handle the failure: Consumers can manage the situation using methods like exceptionally() or handle(), which allow specifying what to do in case of an error during the future's execution.

This function is crucial for building resilient applications, as it allows programmers to reflect failure conditions consistently across various parts of the code.

Future vs. CompletableFuture

The differences between Future and CompletableFuture are significant in Java, particularly concerning their behavior and usability in asynchronous programming. Below, key distinctions are highlighted to understand their unique functionalities.

Blocking vs. Non-Blocking Behavior

One of the most notable differences lies in how these two classes handle task execution.

• Future: This interface is characterized by a blocking behavior. When a thread retrieves the result of a task using the get() method, it halts execution until that result becomes available. This can lead to inefficiencies, particularly in applications requiring responsiveness, such as user interfaces.
• CompletableFuture: In contrast, this class promotes non-blocking behavior, allowing threads to execute other operations while waiting for a task's result. Through methods like thenApply() and thenAccept(), developers can continue to process data without unnecessary delays.

Task Composition Capabilities

Task composition refers to how tasks can be combined and sequenced for execution.

• Future: Composing multiple tasks using Future can be cumbersome. Developers must explicitly manage task completion and callbacks, leading to complex and less readable code.
• CompletableFuture: This class simplifies task chaining with its variety of methods. Functions like thenCompose(), thenCombine(), and allOf() allow for intuitive task composition. This creates more manageable workflows and encapsulates intricate dependencies seamlessly.

Exception Handling Differences

Managing exceptions is crucial in any programming model, especially in asynchronous environments.

• Future: The exception handling mechanism with Future is basic and limited. If a task fails, the developer must wrap the get() call in a try-catch block to handle exceptions, making it cumbersome and less elegant.
• CompletableFuture: Provides a richer exception handling framework. With methods such as exceptionally() and handle(), developers can define recovery strategies directly within the task chain. This enhances code readability and maintains a clear flow of logic in error scenarios.

Control over Completion

The level of control over task completion is fundamental in managing asynchronous tasks.

• Future: Lacks methods for explicitly completing a task. Once a task is submitted, it can only be waited upon or canceled. The inability to control task completion adds complexity to managing task states.
• CompletableFuture: Offers methods such as complete() and completeExceptionally(). This allows developers to programmatically set the outcome of a CompletableFuture, providing greater flexibility in task management and control over various execution paths.

Understanding the CompletableFuture API

The CompletableFuture API provides a comprehensive set of tools for managing asynchronous programming within Java. This section outlines the key elements of the API, including its interface and methods, as well as common scenarios where these features can be utilized effectively.

Interface and Methods

The CompletableFuture interface extends the Future interface, introducing a range of methods that facilitate non-blocking asynchronous operations. The API is designed to be intuitive, allowing developers to chain tasks and handle results in a straightforward manner. Key methods of the CompletableFuture interface include:

• supplyAsync(): This method is used to execute a task asynchronously by supplying a value.
• thenApply(): Transforms the result of the previous stage upon completion.
• thenAccept(): Consumes the result of the previous stage without returning a new value.
• thenRun(): Executes a runnable action after the completion of the previous stage.
• exceptionally(): Provides a way to handle exceptions that occur in the CompletableFuture chain.
• allOf(): Combines multiple CompletableFutures and waits for all to complete.

Common Use Cases

The functionality offered by the CompletableFuture API can be applied across various scenarios to improve application performance and responsiveness. Here are some common use cases:

• UI Responsiveness: By executing tasks asynchronously, applications can maintain a responsive user interface while performing long-running operations.
• Data Processing: CompletableFuture allows for processing data in parallel, effectively utilizing multi-core processors to speed up computation.
• API Calls: When calling external APIs, CompletableFuture can handle the latency often associated with network requests without blocking the main thread.
• Batch Processing: It is well-suited for scenarios requiring the aggregation of results from multiple asynchronous tasks, improving efficiency.
• Background Tasks: Any task that can run in the background without needing immediate feedback can benefit from the features offered by the CompletableFuture API.

Practical Applications of CompletableFuture

Using CompletableFuture in various scenarios enhances performance and responsiveness in applications.

Improving UI Responsiveness

CompletableFuture significantly improves user interface responsiveness by offloading time-consuming tasks to background threads. When executing operations like data fetching or processing, the main UI thread remains free to respond to user inputs, thus enhancing the overall user experience.

Some common practices include:

• Loading data asynchronously to keep the UI interactive.
• Updating UI components once the data is fetched without blocking user interaction.
• Utilizing methods like thenAccept() to directly handle UI updates after a CompletableFuture completes.

This approach minimizes slowdowns during intensive operations, making applications feel faster and more responsive to user interactions. For instance, while a user waits for a file to upload, other actions can still be performed, thereby improving the perceived performance.

Enhancing Server Response Times

CompletableFuture can also be leveraged on server-side applications to halve response times for asynchronous services. Tasks that can run concurrently—such as database queries, external API calls, and data processing—can be handled simultaneously without waiting for each other to complete.

Implementing CompletableFuture in server-side logic includes:

• Executing multiple database calls asynchronously, allowing results from different sources to be combined quickly.
• Using allOf() to wait for several futures to complete before sending a single response to the client.
• Employing non-blocking APIs to enhance throughput and reduce latency.

This non-blocking architecture enables the server to handle more requests simultaneously, leading to enhanced scalability and performance. By utilizing CompletableFuture, systems can efficiently serve clients, maintaining responsiveness even under heavy load.

Performance Considerations

Performance considerations play a crucial role when working with asynchronous programming. Understanding the execution behavior of CompletableFuture and how to leverage executors can greatly influence the efficiency and responsiveness of applications.

Default Executor Behavior

The default behavior for executing CompletableFuture tasks is to utilize the ForkJoinPool.commonPool(). This shared pool is designed to manage a pool of threads effectively, making it suitable for a wide range of tasks.

However, using the common pool can lead to various performance implications. For instance, if many tasks are submitted simultaneously, it may lead to thread contention and increased latency. Consider the following points regarding the default executor:

• Thread Management: The common pool dynamically adjusts the number of threads based on the workload. However, in high-throughput applications, this may not always yield optimal results.
• Blocking Tasks: If a task blocks, it utilizes a thread that could otherwise be serving additional tasks. This can reduce overall throughput and delay task completion.
• Latency and Throughput: The size of the common pool can affect latency and throughput, particularly when the demand for asynchronous tasks fluctuates. Monitoring and tuning may be necessary to ensure efficient use.

Custom Executors

To gain better control over performance characteristics, utilizing custom executors is often recommended. By defining a custom executor, developers can tailor the threading behavior to meet specific application requirements.

There are several advantages to using custom executors:

• Dedicated Resources: Custom executors can allocate and manage a dedicated set of threads for particular tasks. This control can help in avoiding resource contention and optimizing performance for resource-intensive applications.
• Task Prioritization: Developers can implement different strategies for handling tasks, from prioritizing certain tasks over others to managing how and when tasks are executed based on various conditions.
• Reducing Overhead: In situations where the default common pool may be overtaxed, custom executors can reduce the overhead associated with creating and managing threads, leading to better response times.

Creating a custom executor involves implementing the Executor interface. Once set up, you can pass this executor to the CompletableFuture methods:

• Specific Configuration: Adjust thread pool size, task queue capacity, and other parameters to align with expected workloads.
• Scoped Usage: Utilize different executors for different types of tasks, enhancing performance and maintainability of the code.

Advanced CompletableFuture Techniques

Advanced CompletableFuture Techniques provide powerful strategies for managing complex asynchronous workflows. These techniques enhance the capability to coordinate multiple tasks and efficiently handle dependencies.

Combining Multiple CompletableFutures

Combining multiple CompletableFutures allows developers to execute several asynchronous operations concurrently and obtain their results collectively. This is particularly useful when one task's output is needed for another or when tasks are independent but must be completed together.

One of the most effective ways to combine CompletableFutures is through the use of the allOf() method. This method takes an array of CompletableFutures and returns a new CompletableFuture that completes when all of the futures in the array complete. It simplifies the process of running parallel tasks and efficiently gathering their results.

• Example: Combining CompletableFutures using allOf()
• In the following example, three asynchronous tasks are created and combined:CompletableFuture future1 = CompletableFuture.supplyAsync(() -> "Task 1 Result"); CompletableFuture future2 = CompletableFuture.supplyAsync(() -> "Task 2 Result"); CompletableFuture future3 = CompletableFuture.supplyAsync(() -> "Task 3 Result"); CompletableFuture combinedFuture = CompletableFuture.allOf(future1, future2, future3); combinedFuture.thenRun(() -> { try { System.out.println(future1.get()); System.out.println(future2.get()); System.out.println(future3.get()); } catch (Exception e) { e.printStackTrace(); } });

Handling Multiple Dependencies

Managing multiple dependencies in asynchronous programming involves coordinating tasks that may be interdependent. Effective handling of such dependencies ensures that tasks execute in the desired order and only proceed when preconditions are satisfied.

To manage dependencies, developers can use the thenCompose() method. This method enables chaining of CompletableFutures where the next task starts only after the previous task has completed. It is ideal for scenarios where the output of one task is required as input for another.

• Example: Chaining dependent CompletableFutures
• The following example illustrates how to chain tasks using thenCompose():CompletableFuture future = CompletableFuture.supplyAsync(() -> { return 10; }).thenCompose(result -> CompletableFuture.supplyAsync(() -> result * 2)) .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + 5)); future.thenAccept(finalResult -> { System.out.println("Final Result: " + finalResult); });