Java中Future、CompletableFuture、异步与回调解析

最新推荐文章于 2025-03-22 21:58:22 发布

大明湖的狗凯.

最新推荐文章于 2025-03-22 21:58:22 发布

阅读量1.1k

点赞数 27

文章标签： java python 开发语言

本文链接：https://blog.csdn.net/weixin_69477306/article/details/144194120

版权

Java中Future、CompletableFuture、异步与回调解析

文章目录

Java中Future、CompletableFuture、异步与回调解析

一、Future接口

概念与用途
- 基本概念：Future接口是Java中用于表示异步计算结果的一种机制。它就像是一个占位符，代表了一个可能尚未完成的计算任务。当我们提交一个异步任务（比如通过线程池）时，会得到一个Future对象，这个对象可以用来在未来的某个时间点获取任务的结果。
- 主要用途：在多线程编程中，用于处理耗时的操作，避免主线程被长时间阻塞。例如，在一个文件下载程序中，如果直接在主线程中下载文件，可能会导致界面冻结。通过将下载任务提交到线程池并返回一个Future对象，主线程可以继续执行其他操作，之后再通过Future获取下载结果。
方法介绍
- get()方法：用于获取异步任务的结果。它有两种形式，一种是不带参数的get()，另一种是带有超时时间参数的get(long timeout, TimeUnit unit)。
  - 不带参数的get()会阻塞当前线程，直到异步任务完成并返回结果。例如：
```
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<Integer> future = executor.submit(() -> {
    // 模拟一个耗时操作，比如计算1 + 2
    Thread.sleep(2000);
    return 1 + 2;
});
try {
    Integer result = future.get();
    System.out.println("结果: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
```
  - 带有超时时间参数的get()会在指定的超时时间内等待任务完成。如果超时时间内任务未完成，会抛出TimeoutException。这在避免无限期阻塞线程方面非常有用。
- isDone()方法：用于检查异步任务是否已经完成。它返回一个布尔值，如果任务已经完成（正常完成、异常终止或者被取消），则返回true，否则返回false。例如：
```
if (future.isDone()) {
    try {
        System.out.println("任务已完成，结果: " + future.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
} else {
    System.out.println("任务还在进行中...");
}
```
- cancel(boolean mayInterruptIfRunning)方法：用于尝试取消异步任务。参数mayInterruptIfRunning表示是否允许在任务正在运行时中断任务。如果任务还没有开始执行，那么无论mayInterruptIfRunning的值是多少，任务都会被取消，并且cancel()方法返回true。如果任务已经开始执行，并且mayInterruptIfRunning为true，则会尝试中断任务的执行，并且cancel()方法返回true；如果mayInterruptIfRunning为false，则任务不会被中断，只是被标记为取消，cancel()方法返回false。例如：
```
if (future.cancel(true)) {
    System.out.println("任务已取消");
} else {
    System.out.println("任务无法取消");
}
```

二、CompletableFuture类

概念与优势
- 基本概念：CompletableFuture是Java 8引入的一个强大的异步编程工具，它实现了Future接口并且提供了更加强大的异步操作和回调机制。它可以方便地表示一个异步计算任务，并且支持将多个异步任务组合、串联起来，实现复杂的异步流程。
- 优势：
  - 链式调用：可以通过一系列的方法链式调用，如thenApply、thenAccept、thenRun等，来定义在异步任务完成后的操作，使代码更加简洁和可读。
  - 组合异步任务：能够轻松地将多个异步任务组合在一起，比如并行执行多个任务然后合并结果，或者一个任务依赖于另一个任务的结果等情况。
  - 异常处理方便：提供了方便的异常处理机制，通过exceptionally和whenComplete等方法，可以在异步任务出现异常时进行统一的处理。

常用方法解析

创建方式：
- supplyAsync()方法：用于创建一个带有返回值的异步任务。它接受一个Supplier接口的实现作为参数，Supplier接口的get()方法用于提供异步任务的计算逻辑。例如：
```
CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
    // 模拟计算一个整数结果
    return 42;
});
```
- runAsync()方法：用于创建一个没有返回值的异步任务。它接受一个Runnable接口的实现作为参数，Runnable接口的run()方法定义了异步任务的操作。例如：
```
CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
    System.out.println("执行一个无返回值的异步任务");
});
```
回调方法：
- thenApply()方法：用于在异步任务完成后，对其结果进行转换操作。它接受一个Function接口的实现作为参数，Function接口的apply()方法用于对前一个异步任务的结果进行转换，并返回一个新的结果。例如：
```
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10)
      .thenApply(result -> result * 2);
try {
    System.out.println("转换后的结果: " + future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
```
- thenAccept()方法：用于在异步任务完成后，消费其结果，但是没有返回值。它接受一个Consumer接口的实现作为参数，Consumer接口的accept()方法用于对前一个异步任务的结果进行消费。例如：
```
CompletableFuture.supplyAsync(() -> "Hello")
      .thenAccept(result -> System.out.println("消费结果: " + result));
```
- thenRun()方法：用于在异步任务完成后，执行一个没有参数和返回值的操作。它接受一个Runnable接口的实现作为参数，Runnable接口的run()方法定义了要执行的操作。例如：
```
CompletableFuture.supplyAsync(() -> 1)
      .thenRun(() -> System.out.println("异步任务完成后执行的操作"));
```

组合方法：

thenCombine()方法：用于将两个异步任务组合在一起，当两个任务都完成后，使用一个BiFunction接口的实现来合并它们的结果。例如：

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
CompletableFuture<Integer> combinedFuture = future1.thenCombine(future2, (result1, result2) -> result1 + result2);
try {
    System.out.println("组合后的结果: " + combinedFuture.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

allOf()方法：用于等待多个异步任务全部完成。它接受多个CompletableFuture对象作为参数，返回一个新的CompletableFuture，当所有传入的CompletableFuture都完成时，这个新的CompletableFuture才完成。例如：

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> 1);
CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> 2);
CompletableFuture<Void> allFutures = CompletableFuture.allOf(future1, future2);
allFutures.thenRun(() -> {
    try {
        System.out.println("所有任务完成，结果1: " + future1.get() + ", 结果2: " + future2.get());
    } catch (InterruptedException | ExecutionException e) {
        e.printStackTrace();
    }
});

异常处理方法：
- exceptionally()方法：用于在异步任务出现异常时，提供一个替代的结果或者进行异常处理。它接受一个Function接口的实现作为参数，当异步任务抛出异常时，Function接口的apply()方法会被调用，传入的参数是异常对象，apply()方法返回的值会作为异常处理后的结果。例如：
```
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("模拟异常");
}).exceptionally(ex -> {
    System.out.println("捕获到异常: " + ex.getMessage());
    return -1;
});
try {
    System.out.println("异常处理后的结果: " + future.get());
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}
```
- whenComplete()方法：用于在异步任务完成（无论是否出现异常）后执行一个操作。它接受一个BiConsumer接口的实现作为参数，BiConsumer接口的accept()方法会被调用，传入两个参数，第一个参数是异步任务的结果（如果正常完成）或者null（如果出现异常），第二个参数是异常对象（如果出现异常）或者null（如果正常完成）。例如：
```
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> 10);
future.whenComplete((result, ex) -> {
    if (ex == null) {
        System.out.println("任务正常完成，结果: " + result);
    } else {
        System.out.println("任务出现异常: " + ex.getMessage());
    }
});
```

三、异步与回调概念

异步编程概念
- 基本概念：异步编程是一种编程模式，在这种模式下，一个任务（通常是一个耗时的操作）被提交后，程序不会等待这个任务完成，而是继续执行其他操作。在Java中，通过线程池和Future、CompletableFuture等机制来实现异步编程。例如，在一个Web服务器中，接收用户请求后，将一些耗时的数据处理任务（如数据库查询、文件读取等）异步执行，服务器可以在这些任务执行的同时处理其他用户请求，提高系统的并发处理能力。
回调机制概念
- 基本概念：回调是一种异步编程中常用的技术，用于在异步任务完成后通知调用者任务的结果或者执行一些后续操作。在Java的CompletableFuture中，thenApply、thenAccept、thenRun等方法都是回调方法。例如，在一个图形界面应用程序中，当用户点击一个按钮触发一个文件下载任务（异步执行），下载完成后的回调方法可以用于更新界面，显示下载成功的消息并打开文件。
- 与异步编程的关系：回调是异步编程的重要组成部分，它使得异步任务的结果处理更加灵活和可控。通过回调，可以在异步任务完成后自动触发一些操作，而不需要主动去轮询任务是否完成，提高了程序的效率和响应性。例如，在CompletableFuture中，通过链式的回调方法，可以将多个异步任务按照特定的顺序或者逻辑组合起来，实现复杂的异步处理流程。