Transform a Future into CompletableFuture

1. Introduction

In this tutorial, we’ll explore how to transform a Future into a CompletableFuture. This transformation allows us to leverage the advanced features of CompletableFuture, such as non-blocking operations, task chaining, and better error handling, while still working with APIs or libraries that return Future.

2. Why Transform Future to CompletableFuture?

The Future interface in Java represents the result of an asynchronous computation. It provides methods to check if the computation is complete, wait for its completion, and retrieve the result.

However, Future has limitations, such as blocking calls that require the use of get() to retrieve results. It also lacks support for chaining multiple asynchronous tasks or handling callbacks.

On the other hand, CompletableFuture, introduced in Java 8, addresses these shortcomings. It supports non-blocking operations through methods like thenApply() and thenAccept() for task chaining and callbacks, as well as error handling using exceptionally().

By transforming a Future into a CompletableFuture, we can leverage these features while still working with APIs or libraries that return Future.

3. Step-by-Step Transformation

In this section, we’ll demonstrate how to transform a Future into a CompletableFuture.

3.1. Simulating a Future Using ExecutorService

To understand how Future works, we’ll first simulate an asynchronous computation using ExecutorService. The ExecutorService is a framework for managing and scheduling tasks in separate threads. This will help us understand the blocking nature of the Future:

@Test
void givenFuture_whenGet_thenBlockingCall() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    Future<String> future = executor.submit(() -> {
        Thread.sleep(1000);
        return "Hello from Future!";
    });

    String result = future.get();
    executor.shutdown();

    assertEquals("Hello from Future!", result);
}

In this code, we use executor.submit() to simulate a long-running task that returns a Future object. The future.get() call blocks the main thread until the computation is complete, after which the result is printed.

This blocking behavior highlights one of the limitations of Future that we aim to address with CompletableFuture.

3.2. Wrapping a Future into a CompletableFuture

To transform a Future into a CompletableFuture, we need to bridge the gap between the blocking nature of Future and the non-blocking, callback-driven design of CompletableFuture.

To achieve this, we create a method called toCompletableFuture(), which takes a Future and an ExecutorService as input and returns a CompletableFuture:

static <T> CompletableFuture<T> toCompletableFuture(Future<T> future, ExecutorService executor) {
    CompletableFuture<T> completableFuture = new CompletableFuture<>();
    executor.submit(() -> {
        try {
            completableFuture.complete(future.get());
        } catch (Exception e) {
            completableFuture.completeExceptionally(e);
        }
    });
    return completableFuture;
}

In the example above, the toCompletableFuture() method starts by creating a new CompletableFuture. Then, a separate thread from a cached thread pool monitors the Future.

When the Future completes, its result is retrieved using the blocking get() method and then passed to the CompletableFuture using the complete() method. If the Future throws an exception, the CompletableFuture is completed exceptionally to ensure the errors are propagated.

This wrapped CompletableFuture allows us to handle results asynchronously and use callback methods like thenAccept(). Let’s demonstrate how to use the toCompletableFuture():

@Test
void givenFuture_whenWrappedInCompletableFuture_thenNonBlockingCall() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    Future<String> future = executor.submit(() -> {
        Thread.sleep(1000);
        return "Hello from Future!";
    });

    CompletableFuture<String> completableFuture = toCompletableFuture(future, executor);

    completableFuture.thenAccept(result -> assertEquals("Hello from Future!", result));

    executor.shutdown();
}

Unlike future.get(), this approach avoids blocking the main thread and makes the code more flexible. We can also chain multiple stages together, allowing for more sophisticated processing of results.

For example, we can transform the result of the Future and then perform additional operations:

@Test
void givenFuture_whenTransformedAndChained_thenCorrectResult() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    Future<String> future = executor.submit(() -> {
        Thread.sleep(1000);
        return "Hello from Future!";
    });

    CompletableFuture<String> completableFuture = toCompletableFuture(future, executor);

    completableFuture
      .thenApply(result -> result.toUpperCase()) // Transform result
      .thenAccept(transformedResult -> assertEquals("HELLO FROM FUTURE!", transformedResult));

    executor.shutdown();
}

In this example, after transforming the result to uppercase, we print the transformed result. This showcases the power of chaining operations with CompletableFuture.

3.3. Using CompletableFuture’s supplyAsync() Method

Another approach is to utilize the CompletableFuture‘s method called supplyAsync(), which can execute a task asynchronously and return its result as a CompletableFuture.

Let’s see how we can wrap the blocking Future call inside the supplyAsync() method to achieve the transformation:

@Test
void givenFuture_whenWrappedUsingSupplyAsync_thenNonBlockingCall() throws ExecutionException, InterruptedException {
    ExecutorService executor = Executors.newSingleThreadExecutor();

    Future<String> future = executor.submit(() -> {
        Thread.sleep(1000);
        return "Hello from Future!";
    });

    CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
        try {
            return future.get();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    });

    completableFuture.thenAccept(result -> assertEquals("Hello from Future!", result));

    executor.shutdown();
}

In this approach, we use CompletableFuture.supplyAsync() to execute a task asynchronously. The task wraps the blocking call future.get() inside a lambda expression. This way, the result of the Future is retrieved in a non-blocking manner, enabling us to use CompletableFuture methods for callbacks and chaining.

This method is simpler as it avoids managing separate threads manually. The CompletableFuture handles the asynchronous execution for us.

4. Combine Multiple Future Objects into One CompletableFuture

In some scenarios, we may need to work with multiple Future objects that should be combined into a single CompletableFuture. This is common when aggregating results from different tasks or waiting for all tasks to be completed before proceeding with further processing. Using CompletableFuture, we can efficiently combine multiple Future objects and handle them in a non-blocking manner.

To combine multiple Future objects, we first transform them into CompletableFuture instances. Then, we use CompletableFuture.allOf() to wait for all the tasks to be completed. Let’s see an example of how this can be implemented:

static CompletableFuture<Void> allOfFutures(List<Future<String>> futures, ExecutorService executor) {
    // Convert all Future objects into CompletableFuture instances
    List<CompletableFuture<String>> completableFutures = futures.stream()
      .map(future -> FutureToCompletableFuture.toCompletableFuture(future, executor))
      .toList();

    return CompletableFuture.allOf(completableFutures.toArray(new CompletableFuture[0]));
}

Once all tasks are complete, the CompletableFuture.allOf() method signals the completion. To demonstrate this, let’s consider a scenario where multiple tasks return Future objects with strings as results. We’ll aggregate the results and ensure all tasks are completed successfully:

@Test
void givenMultipleFutures_whenCombinedWithAllOf_thenAllResultsAggregated() throws Exception {
    ExecutorService executor = Executors.newFixedThreadPool(3);

    List<Future<String>> futures = List.of(
        executor.submit(() -> {
            return "Task 1 Result";
        }),
        executor.submit(() -> {
            return "Task 2 Result";
        }),
        executor.submit(() -> {
            return "Task 3 Result";
        })
    );

    CompletableFuture<Void> allOf = allOfFutures(futures, executor);

    allOf.thenRun(() -> {
        try {
            List<String> results = futures.stream()
              .map(future -> {
                  try {
                      return future.get();
                  } catch (Exception e) {
                      throw new RuntimeException(e);
                  }
              })
              .toList();
            assertEquals(3, results.size());
            assertTrue(results.contains("Task 1 Result"));
            assertTrue(results.contains("Task 2 Result"));
            assertTrue(results.contains("Task 3 Result"));
        } catch (Exception e) {
            fail("Unexpected exception: " + e.getMessage());
        }
    }).join();

    executor.shutdown();
}

In this example, we simulate three tasks, each returning a result using an ExecutorService. Next, each task is submitted and returns a Future object. We pass the list of Future objects to the allOfFutures() method, which converts them to CompletableFuture and combines them using CompletableFuture.allOf().

When all tasks are complete, we use the thenRun() method to aggregate the results and assert their correctness. This approach is useful in scenarios like parallel processing of independent tasks where results need to be aggregated.

5. Conclusion

In this tutorial, we explored how to transform a Future into a CompletableFuture in Java. By leveraging CompletableFuture, we can take advantage of non-blocking operations, task chaining, and robust exception handling. This transformation is particularly useful when we want to enhance the capabilities of our asynchronous programming model.