Future vs CompletableFuture classes in Java

The Future and CompletableFuture classes in Java both represent asynchronous computations, but they have some differences in terms of functionality and usage.

Future:

• Syntax:

  Future<ResultType> future = executorService.submit(Callable<ResultType> task);

• Example:

ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> future = executor.submit(() -> {
    Thread.sleep(2000); // Simulate a time-consuming task
    return "Hello, from Future!";
});
String result = future.get(); // Blocking call to get the result
System.out.println(result);
executor.shutdown();

CompletableFuture:

• Syntax:

  CompletableFuture<ResultType> future = CompletableFuture.supplyAsync(Supplier<ResultType> supplier);

• Example:

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000); // Simulate a time-consuming task
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello, from CompletableFuture!";
});
future.thenAccept(result -> System.out.println(result)); // Non-blocking callback

• Differences:

1. Completion Handling: Future relies on blocking methods like get() for result retrieval, while CompletableFuture provides non-blocking methods like thenAccept() for completion handling.
2. Composition: CompletableFuture supports fluent API and allows chaining of multiple asynchronous operations, whereas Future does not.
3. Explicit Completion: CompletableFuture allows explicit completion via methods like complete() or completeExceptionally(), which can be useful in certain scenarios.

Poll:

Which Java related Questions would you like to read more about?

• Java 8, 11, 17 feature
• Streams
• Spring, Spring Boot
• Multi Threading
• Design Patterns

Leave a comment below!

Discover the more Java interview question for experienced developers! YouTube Channel Link