Detailed Explanation of CompletableFuture in Java

I. Overview of CompletableFuture
CompletableFuture is a powerful asynchronous programming utility class introduced in Java 8, located in the java.util.concurrent package. It implements the Future and CompletionStage interfaces, not only supporting the retrieval of asynchronous computation results but also providing rich callback functions and compositional operations, enabling elegant handling of complex asynchronous task chains.

II. Core Features and Advantages

1. Asynchronous Execution: Time-consuming tasks can be executed in background threads, avoiding blocking the main thread.
2. Chained Invocation: Supports serial or parallel execution of multiple asynchronous tasks.
3. Exception Handling: Provides a complete exception handling mechanism.
4. Result Transformation: Enables various transformations and processing of asynchronous results.
5. Compositional Operations: Supports the composition of multiple CompletableFutures.

III. Four Ways to Create CompletableFuture

3.1 Using runAsync() to Create a Task with No Return Value

// Create an asynchronous task that returns no result
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("Asynchronous task executing...");
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("Asynchronous task completed");
});

3.2 Using supplyAsync() to Create a Task with a Return Value

// Create an asynchronous task that returns a computation result
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("Computation task starting");
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Computation result";
});

3.3 Using completedFuture() to Create an Already Completed Future

// Directly create a task that is already completed
CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Immediate result");

3.4 Custom Thread Pool

// Use a custom thread pool to execute asynchronous tasks
ExecutorService customExecutor = Executors.newFixedThreadPool(5);
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    return "Executed using custom thread pool";
}, customExecutor);

IV. Result Retrieval and Basic Operations

4.1 Synchronous Result Retrieval

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello");
try {
    String result = future.get(); // Blocks until the result is obtained
    System.out.println(result); // Output: Hello
} catch (Exception e) {
    e.printStackTrace();
}

4.2 Asynchronous Callback Handling

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "World");

// thenApply: Transform the result
CompletableFuture<String> transformed = future.thenApply(result -> "Hello " + result);

// thenAccept: Consume the result, returning no new value
future.thenAccept(result -> System.out.println("Result received: " + result));

// thenRun: Execute an action after the task completes, not caring about the result
future.thenRun(() -> System.out.println("Task completed"));

V. Detailed Explanation of Composition Operations

5.1 thenCompose() - Chain Composition

// Simulate a user information query chain
CompletableFuture<String> getUserInfo = CompletableFuture.supplyAsync(() -> "User123");

// thenCompose is used to connect two dependent asynchronous tasks
CompletableFuture<String> result = getUserInfo.thenCompose(userId -> 
    CompletableFuture.supplyAsync(() -> userId + "'s detailed information")
);

System.out.println(result.get()); // Output: User123's detailed information

5.2 thenCombine() - Parallel Composition

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 10);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 20);

// After both tasks are completed, combine their results
CompletableFuture<Integer> combined = future1.thenCombine(future2, (result1, result2) -> 
    result1 + result2
);

System.out.println(combined.get()); // Output: 30

5.3 allOf() - Wait for All Tasks to Complete

CompletableFuture<String> task1 = CompletableFuture.supplyAsync(() -> "Task1");
CompletableFuture<String> task2 = CompletableFuture.supplyAsync(() -> "Task2");
CompletableFuture<String> task3 = CompletableFuture.supplyAsync(() -> "Task3");

CompletableFuture<Void> allTasks = CompletableFuture.allOf(task1, task2, task3);

allTasks.thenRun(() -> {
    System.out.println("All tasks completed");
    try {
        System.out.println("Task1 result: " + task1.get());
        System.out.println("Task2 result: " + task2.get());
        System.out.println("Task3 result: " + task3.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
});

5.4 anyOf() - Wait for Any Task to Complete

CompletableFuture<String> fastTask = CompletableFuture.supplyAsync(() -> {
    try { Thread.sleep(100); } catch (InterruptedException e) {}
    return "Fast task";
});

CompletableFuture<String> slowTask = CompletableFuture.supplyAsync(() -> {
    try { Thread.sleep(1000); } catch (InterruptedException e) {}
    return "Slow task";
});

CompletableFuture<Object> firstCompleted = CompletableFuture.anyOf(fastTask, slowTask);
System.out.println("First completed task: " + firstCompleted.get()); // Output: Fast task

VI. Exception Handling Mechanism

6.1 exceptionally() - Exception Recovery

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) throw new RuntimeException("Simulated exception");
    return "Normal result";
});

// Provide a default value when an exception occurs
CompletableFuture<String> safeFuture = future.exceptionally(throwable -> {
    System.out.println("Exception caught: " + throwable.getMessage());
    return "Default result";
});

System.out.println(safeFuture.get()); // Output: Default result

6.2 handle() - Unified Handling of Normal and Exceptional Cases

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (Math.random() > 0.5) {
        throw new RuntimeException("Random exception");
    }
    return "Success result";
});

CompletableFuture<String> handled = future.handle((result, throwable) -> {
    if (throwable != null) {
        return "Exception handling result";
    }
    return result;
});

6.3 whenComplete() - Callback Upon Completion

CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Test task");

future.whenComplete((result, throwable) -> {
    if (throwable != null) {
        System.out.println("Task failed: " + throwable.getMessage());
    } else {
        System.out.println("Task succeeded: " + result);
    }
});

VII. Practical Application Scenarios

7.1 Parallel Invocation of Multiple Services

// Simulate parallel calls to three microservices
CompletableFuture<String> userService = CompletableFuture.supplyAsync(() -> "User data");
CompletableFuture<String> orderService = CompletableFuture.supplyAsync(() -> "Order data");
CompletableFuture<String> productService = CompletableFuture.supplyAsync(() -> "Product data");

CompletableFuture<Void> allServices = CompletableFuture.allOf(userService, orderService, productService);

allServices.thenRun(() -> {
    try {
        String user = userService.get();
        String order = orderService.get();
        String product = productService.get();
        System.out.println("Aggregated result: " + user + ", " + order + ", " + product);
    } catch (Exception e) {
        e.printStackTrace();
    }
});

7.2 Asynchronous Task Pipeline

CompletableFuture<String> pipeline = CompletableFuture
    .supplyAsync(() -> "Raw data")                    // Step 1: Obtain data
    .thenApplyAsync(data -> data + " -> Processed")      // Step 2: Process data
    .thenApplyAsync(data -> data + " -> Validated")      // Step 3: Validate data
    .thenApplyAsync(data -> data + " -> Final result");   // Step 4: Generate final result

pipeline.thenAccept(finalResult -> 
    System.out.println("Pipeline result: " + finalResult)
);

VIII. Best Practices and Considerations

1. Use Thread Pools Reasonably: Avoid using the default ForkJoinPool for blocking I/O operations.
2. Exception Handling: Always add exception handling logic for asynchronous tasks.
3. Resource Cleanup: Promptly close custom thread pools.
4. Avoid Blocking: Prefer using callbacks over the get() method.
5. Timeout Control: Use the orTimeout() method to set timeout limits.

CompletableFuture provides powerful support for asynchronous programming in Java. By mastering its various operators, one can write efficient and highly readable asynchronous code.