Java Future and CompletableFuture

1. Introduction

In Java, concurrency is a powerful feature that allows multiple threads to run simultaneously. This lesson focuses on two key classes in the Java Concurrency framework: Future and CompletableFuture.

2. Key Concepts

• Concurrency: The ability to run multiple tasks simultaneously.
• Thread: The smallest unit of processing that can be scheduled by an operating system.
• ExecutorService: A high-level replacement for managing threads.

3. Future

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

4. CompletableFuture

CompletableFuture is an extension of Future that allows you to write non-blocking asynchronous code. It can be manually completed and allows for chaining multiple asynchronous tasks.

5. Code Examples

import java.util.concurrent.CompletableFuture;

public class FutureExample {
    public static void main(String[] args) {
        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            // Simulate a long-running task
            try { Thread.sleep(1000); } catch (InterruptedException e) { }
            return 42;
        });

        future.thenAccept(result -> System.out.println("Result: " + result));
        // Wait for the future to complete
        future.join();
    }
}
        

6. Best Practices

Always handle exceptions while using CompletableFuture for better resilience.

• Use completeExceptionally to handle errors.
• Chain tasks using thenApply or thenAccept for better readability.
• Avoid blocking calls like get() whenever possible.

7. FAQ