使用 Completable Future 处理 Java 中的多线程

1. 理解完整的未来

CompletableFuture 是 java.util.concurrent 包的一部分，提供了一种以更具可读性和可维护性的方式编写异步、非阻塞代码的方法。它代表异步计算的未来结果。

1.1 创建一个简单的CompletableFuture

从 CompletableFuture 开始，您可以创建一个简单的异步任务。这是一个例子：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("Running asynchronously...");
            // Simulate a long-running task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        future.join(); // Wait for the task to complete
        System.out.println("Task completed.");
    }
}

• CompletableFuture.runAsync() 异步执行任务。
• future.join() 阻塞主线程，直到任务完成。

演示结果：

Running asynchronously...
Task completed.

1.2 将 CompletableFuture 与结果结合使用

您还可以使用CompletableFuture返回异步任务的结果：

import java.util.concurrent.CompletableFuture;

public class CompletableFutureWithResult {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            // Simulate a computation
            return 5 * 5;
        });

        future.thenAccept(result -> {
            System.out.println("The result is: " + result);
        }).join();
    }
}

• CompletableFuture.supplyAsync() 用于返回结果的任务。
• thenAccept() 计算完成后处理结果。

演示结果：

The result is: 25

2. 组合多个CompletableFuture

处理多个异步任务是一个常见的用例。 CompletableFuture 提供了多种组合 future 的方法。

2.1 将 Future 与 thenCombine 结合起来

您可以组合多个 CompletableFutures 的结果：

import java.util.concurrent.CompletableFuture;

public class CombiningFutures {
    public static void main(String[] args) {
        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 5);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 10);

        CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);

        combinedFuture.thenAccept(result -> {
            System.out.println("Combined result: " + result);
        }).join();
    }
}

• thenCombine () 组合两个 future 的结果。
• 使用 thenAccept () 处理组合结果。

演示结果：

Combined result: 15

2.2 使用 allOf 处理多个 Future

当需要等待多个 future 完成时，使用 CompletableFuture.allOf():

import java.util.concurrent.CompletableFuture;

public class AllOfExample {
    public static void main(String[] args) {
        CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
            // Simulate task
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
            // Simulate another task
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        CompletableFuture<Void> allOfFuture = CompletableFuture.allOf(future1, future2);

        allOfFuture.join();
        System.out.println("All tasks completed.");
    }
}

• CompletableFuture.allOf() 等待所有给定的 future 完成。
• join() 确保主线程等待，直到所有任务完成。

演示结果：

All tasks completed.

3. CompletableFuture 的错误处理

处理错误在异步编程中至关重要。 CompletableFuture 提供了管理异常的方法。

3.1 使用异常处理异常

使用异常()处理异步任务中的异常：

import java.util.concurrent.CompletableFuture;

public class ExceptionHandlingExample {
    public static void main(String[] args) {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            throw new RuntimeException("Something went wrong!");
        }).exceptionally(ex -> {
            System.out.println("Exception occurred: " + ex.getMessage());
            return null;
        });

        future.join();
    }
}

• 异常 () 捕获并处理异常。
• 它允许您提供后备结果或处理错误。

演示结果：

Exception occurred: Something went wrong!

4.CompletableFuture的优缺点

4.1 优点

• 异步执行：高效处理并发运行的任务，而不阻塞主线程。
• 提高了可读性：与传统的回调方法相比，提供了一种更具可读性和可维护性的方式来处理异步代码。
• 丰富的 API ：提供多种方法来组合、处理和组合多个 future。

4.2 缺点

• 复杂性：CompletableFuture 虽然功能强大，但会在管理和调试异步代码时引入复杂性。
• 异常处理：处理异常有时可能很棘手，尤其是在具有多个阶段的复杂场景中。

5. 结论

在本指南中，我们探索了如何使用 CompletableFuture 处理 Java 中的并发请求。从创建简单的异步任务到组合多个 future 和处理错误，CompletableFuture 提供了一种健壮且灵活的异步编程方法。

如果您有任何疑问或需要进一步帮助，请随时在下面发表评论。我很乐意提供帮助！

阅读更多帖子：使用 Completable Future 处理 Java 中的多线程

以上是使用 Completable Future 处理 Java 中的多线程的详细内容。更多信息请关注PHP中文网其他相关文章！