java future vs completablefuture

Emily 55 Published: 07/01/2024

java future vs completablefuture

I'll respond in English as you requested!

Java's Future and CompletableFuture are two fundamental concepts that play a crucial role in asynchronous programming. Both interfaces share some similarities, but they differ in their design and purpose.

The Good Old Future

Introduced in Java 5 (2004), the Future interface represents the result of an asynchronous computation. A Future object encapsulates the value returned by a computational task or operation. It provides methods to check if the computation is complete, retrieve its result, and cancel it.

Here are some key aspects of Future:

Blocking: When you call get() on a Future, it blocks your current thread until the computation completes. Single-threaded execution: The computation associated with a Future runs in a single thread, which can lead to performance bottlenecks when dealing with multiple concurrent operations.

Enter CompletableFuture (Java 8, 2013)

To address some of the limitations and frustrations of working with plain old Future, Java 8 introduced CompletableFuture. This new class provides a more powerful and expressive API for working with asynchronous computations.

Here are some key benefits of CompletableFuture:

Non-blocking: Unlike Future.get(), which blocks your thread, CompletableFuture allows you to handle the result asynchronously using methods like thenAccept() or exceptionally(). Chainable completions: You can compose multiple operations and transformations on top of each other, creating a chain of asynchronous computations that can be completed in parallel. Exception handling: CompletableFuture provides built-in support for exception handling using methods like exceptionally() or handle(), making it easier to handle errors and exceptions in your asynchronous code.

Key differences

To summarize:

Future is more lightweight, but its simplicity can lead to blocking and single-threaded execution issues. CompletableFuture is designed to be more powerful and expressive, offering non-blocking, chainable completions, and robust exception handling.

In summary, when you need a simple, lightweight way to represent the result of an asynchronous computation, Future might be sufficient. However, if you're working with complex, interconnected asynchronous operations that require more advanced control and error handling, CompletableFuture is likely the better choice.

I hope this helps clarify the differences between Java's Future and CompletableFuture.

Does Java have futures?

I'd be happy to respond in English for you!

Java does not have a built-in concept like C# or F#'s await keyword, which allows asynchronous programming with futures. However, Java provides several mechanisms to implement asynchronous programming and deal with futures.

One common approach is to use the Future class from the java.util.concurrent package, which represents a computation that may not have completed yet. A Future can be used to retrieve the result of an asynchronous operation when it becomes available. You can create a Future using the ExecutorService.submit() method or by calling one of the CompletableFuture.supplyAsync() methods.

Here's an example of how you might use Futures to asynchronously compute the sum of two numbers:

import java.util.concurrent.Callable;

import java.util.concurrent.ExecutionException;


import java.util.concurrent.ExecutorService;


import java.util.concurrent.Executors;


public class Main {


public static void main(String[] args) {


ExecutorService executor = Executors.newSingleThreadExecutor();


Callable sumCallable1 = () -> computeSum(5, 3);


Callable sumCallable2 = () -> computeSum(10, 4);


Future future1 = executor.submit(sumCallable1);


Future future2 = executor.submit(sumCallable2);


try {


int sum1 = future1.get();


int sum2 = future2.get();


System.out.println("The total is: " + (sum1 + sum2));


} catch (InterruptedException | ExecutionException e) {


System.out.println("An error occurred: " + e.getMessage());


}


}


private static int computeSum(int a, int b) {


// simulate some work


try { Thread.sleep(2000); } catch (InterruptedException e) {}


return a + b;


}


}

In this example, computeSum() is a method that performs the actual computation. The Future class is used to represent the asynchronous computations and retrieve their results when they become available.

Another way to implement futures in Java is by using reactive programming libraries like Project Reactor or RxJava. These libraries provide high-level APIs for composing asynchronous workflows and handling errors.

Overall, while Java may not have a built-in Future keyword like some other languages, it provides several mechanisms for implementing asynchronous programming with futures, giving developers the flexibility to choose the approach that best fits their needs.

Related Articles