CompletableFuture

于 2024-07-15 16:54:32 发布
阅读量937 收藏 9
点赞数 16
分类专栏： Java开发 文章标签： 网络 服务器 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43349479/article/details/140443058
版权

CompletableFuture的用法

CompletableFuture 是 Java 8 引入的一个类，用于处理异步编程。它提供了丰富的 API 来处理异步任务的执行、组合和处理结果。以下是 CompletableFuture 的一些常见用法：

1. 创建 CompletableFuture

  • 直接创建一个完成的 CompletableFuture：
CompletableFuture<String> completedFuture = CompletableFuture.completedFuture("Hello");
  • 通过异步任务创建 CompletableFuture：
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Running in a separate thread");
});

2. 组合多个 CompletableFuture

  • 使用 thenApply 处理结果：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenApply(result -> result + " World");
  • 使用 thenAccept 处理结果，无返回值：
CompletableFuture.supplyAsync(() -> "Hello")
    .thenAccept(result -> System.out.println(result + " World"));
  • 使用 thenCompose 链接多个异步任务：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> "Hello")
    .thenCompose(result -> CompletableFuture.supplyAsync(() -> result + " World"));
  • 使用 thenCombine 合并两个 CompletableFuture 的结果：
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

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

3. 处理异常

  • 使用 exceptionally 处理异常：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception occurred");
    }
    return "Hello";
}).exceptionally(ex -> "Error: " + ex.getMessage());
  • 使用 handle 处理结果和异常：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    if (true) {
        throw new RuntimeException("Exception occurred");
    }
    return "Hello";
}).handle((result, ex) -> {
    if (ex != null) {
        return "Error: " + ex.getMessage();
    }
    return result;
});

4. 等待所有任务完成

  • 使用 allOf 等待所有 CompletableFuture 完成：
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello");
CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> "World");

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

allOf.thenRun(() -> {
    try {
        System.out.println(future1.get() + " " + future2.get());
    } catch (Exception e) {
        e.printStackTrace();
    }
});

5. 等待任意一个任务完成

  • 使用 anyOf 等待任意一个 CompletableFuture 完成：
CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
});

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

CompletableFuture<Object> anyOf = CompletableFuture.anyOf(future1, future2);

anyOf.thenAccept(result -> System.out.println(result));

6. 超时处理

  • 使用 orTimeout 设置超时：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
}).orTimeout(1, TimeUnit.SECONDS).exceptionally(ex -> "Timeout: " + ex.getMessage());
  • 使用 completeOnTimeout 设置超时并提供默认值：
CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    try {
        Thread.sleep(2000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "Hello";
}).completeOnTimeout("Default Value", 1, TimeUnit.SECONDS);

总结

CompletableFuture 提供了丰富的 API 来处理异步任务，包括任务的创建、组合、异常处理、超时处理等。通过这些 API，你可以轻松地实现复杂的异步编程逻辑。

如何获取异步执行的结果

在 Java 中，CompletableFuture 提供了多种方式来获取异步执行的结果。以下是几种常见的方法：

  1. get() 方法：
    这是最常用的方法之一。它会阻塞当前线程，直到 CompletableFuture 完成并返回结果。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

try {
    String result = future.get();
    System.out.println(result); // 输出: Hello, World!
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

  2. join() 方法：
    类似于 get() 方法，但它会抛出未经检查的异常（CompletionException），而不是受检异常。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

String result = future.join();
System.out.println(result); // 输出: Hello, World!

  3. thenApply() 方法：
    该方法允许在 CompletableFuture 完成后对结果进行处理，并返回一个新的 CompletableFuture。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

CompletableFuture<String> processedFuture = future.thenApply(result -> {
    return result + " Processed!";
});

String processedResult = processedFuture.join();
System.out.println(processedResult); // 输出: Hello, World! Processed!

  4. thenAccept() 方法：
    该方法允许在 CompletableFuture 完成后对结果进行消费，但不返回新的 CompletableFuture。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

future.thenAccept(result -> {
    System.out.println(result); // 输出: Hello, World!
});

  5. whenComplete() 方法：
    该方法允许在 CompletableFuture 完成后执行一个回调，无论是正常完成还是异常完成。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

future.whenComplete((result, exception) -> {
    if (exception == null) {
        System.out.println(result); // 输出: Hello, World!
    } else {
        exception.printStackTrace();
    }
});

  6. handle() 方法：
    该方法允许在 CompletableFuture 完成后对结果或异常进行处理，并返回一个新的 CompletableFuture。

    CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    // 异步任务
    return "Hello, World!";
});

CompletableFuture<String> handledFuture = future.handle((result, exception) -> {
    if (exception == null) {
        return result + " Handled!";
    } else {
        return "Exception occurred!";
    }
});

String handledResult = handledFuture.join();
System.out.println(handledResult); // 输出: Hello, World! Handled!

void类型，调用get方法后

如果 CompletableFuture 的类型是 Void，你仍然可以使用 get() 方法来等待异步任务的完成。尽管 get() 方法会返回 null，但它会确保异步任务已经完成。

以下是一个示例：

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

try {
    // 调用 get() 方法等待任务完成
    future.get();
    System.out.println("Task completed");
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
}

在这个示例中，CompletableFuture.runAsync() 方法创建了一个异步任务，该任务不返回任何结果（即 Void 类型）。调用 get() 方法会阻塞当前线程，直到异步任务完成。

其他获取 Void 类型 CompletableFuture 结果的方法：

  1. join() 方法：
    类似于 get() 方法，但它会抛出未经检查的异常（CompletionException），而不是受检异常。

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

// 调用 join() 方法等待任务完成
future.join();
System.out.println("Task completed");

  2. thenRun() 方法：
    该方法允许在 CompletableFuture 完成后执行一个回调，但不返回新的 CompletableFuture。

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

future.thenRun(() -> {
    System.out.println("Task completed");
});

  3. whenComplete() 方法：
    该方法允许在 CompletableFuture 完成后执行一个回调，无论是正常完成还是异常完成。

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

future.whenComplete((result, exception) -> {
    if (exception == null) {
        System.out.println("Task completed");
    } else {
        exception.printStackTrace();
    }
});

  4. handle() 方法：
    该方法允许在 CompletableFuture 完成后对结果或异常进行处理，并返回一个新的 CompletableFuture。

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

CompletableFuture<Void> handledFuture = future.handle((result, exception) -> {
    if (exception == null) {
        System.out.println("Task completed");
    } else {
        System.out.println("Exception occurred");
    }
    return null;
});

// 调用 join() 方法等待处理完成
handledFuture.join();

如果不需要等待返回值

如果不需要等待 CompletableFuture 的返回值，只需要启动异步任务并继续执行后续代码，可以使用以下几种方法：

  1. runAsync() 方法：
    该方法用于启动一个不返回结果的异步任务。

    CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

// 后续代码
System.out.println("Task has been started");

  2. supplyAsync() 方法：
    该方法用于启动一个返回结果的异步任务，但你可以忽略返回值。

    CompletableFuture.supplyAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
    return "Result";
});

// 后续代码
System.out.println("Task has been started");

  3. 链式调用：
    如果你需要在异步任务完成后执行一些操作，但不需要等待结果，可以使用 thenRun() 或 thenAccept() 方法。

    CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    // 异步任务
    System.out.println("Task is running");
});

future.thenRun(() -> {
    // 异步任务完成后的操作
    System.out.println("Task completed");
});

// 后续代码
System.out.println("Task has been started");

  4. 组合多个异步任务：
    如果你有多个异步任务，并且不需要等待它们的结果，可以使用 allOf() 方法。

    CompletableFuture<Void> future1 = CompletableFuture.runAsync(() -> {
    // 异步任务1
    System.out.println("Task 1 is running");
});

CompletableFuture<Void> future2 = CompletableFuture.runAsync(() -> {
    // 异步任务2
    System.out.println("Task 2 is running");
});

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

allFutures.thenRun(() -> {
    // 所有异步任务完成后的操作
    System.out.println("All tasks completed");
});

// 后续代码
System.out.println("Tasks have been started");

总结：如果你不需要等待 CompletableFuture 的返回值，只需要启动异步任务并继续执行后续代码，可以直接调用 runAsync() 或 supplyAsync() 方法，并在需要时使用链式调用来处理任务完成后的操作。这样可以确保异步任务在后台执行，而主线程继续执行后续代码。

你这个代码我看不懂
关注
  • 16
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java8 CompletableFuture底层实现及使用详解
程序员野蛮成长
07-14 884
该方法的区别在于，它将任务串联起来，可以实现多个异步操作的链式调用。然后，通过thenApply方法将该CompletableFuture对象转换为一个新的CompletableFuture对象，用于异步执行一个返回整数类型的任务，转换函数是将字符串长度作为结果返回。thenCompose方法接收一个Function类型的参数，该函数用于将一个CompletableFuture对象的结果作为下一个CompletableFuture对象的输入，并返回一个新的CompletableFuture对象。
一篇文章搞清楚Java中CompletableFuture的使用
qq_43217697的博客
10-23 4161
一篇文章搞清楚Java中CompletableFuture的使用
java中CompletableFuture的一些方法讲解
weixin_44073836的博客
03-08 1971
java中CompletableFuture
Java CompletableFuture
最新发布
qq_33240556的博客
05-29 206
提供了强大的异步编程能力，使得处理复杂的异步逻辑变得更加简单和直观。通过使用它的丰富 API，可以轻松地处理任务的完成、合并结果和异常处理等操作，从而大大简化了异步编程的复杂性。
Java之CompletableFuture异步、组合计算基本用法
OceanSky的专栏
10-29 3838
CompletableFuture是Java8新增的Api,该类实现了Future和ComplateStage两个接口，提供了强大的Future扩展功能，可以简化异步编程的复杂性，提供了函数编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。 Future:表示一个任务的生命周期，并提供了相应的方法来判断是否已经完成或取消，以及获取任务的...
多线程CompletableFuture
没有伞的孩子必须努力奔跑！—小林
10-18 1567
自己在项目中使用CompletableFuture比较多，看到很多开源框架中也大量使用到了CompletableFuture。 因此，专门写一篇文章来介绍这个 Java 8 才被引入的一个非常有用的用于异步编程的类。 简单介绍 CompletableFuture同时实现了Future和CompletionStage接口。 public class CompletableFuture<T> implements Future<T>, CompletionSt...
在Spring Boot2中使用CompletableFuture的方法教程
08-26
在Spring Boot 2中，`CompletableFuture`是一个强大的工具，用于构建异步、非阻塞的应用程序。结合`@Async`注解，可以轻松地实现并发处理，提高应用的性能和响应速度。本文将深入探讨如何在Spring Boot 2中有效地...
Java8 CompletableFuture详解
09-04
Java 8 的 `CompletableFuture` 是对传统 `Future` 接口的重要扩展，它引入了丰富的功能，使得异步编程和事件驱动模型更加便捷。`CompletableFuture` 不仅集成了 Guava 的 `ListenableFuture` 和 `SettableFuture` ...
CompletableFuture 异步处理
07-16
CompletableFuture<String> future = CompletableFuture.supplyAsync(task); future.thenAccept(result -> System.out.println("Received result: " + result)); ``` 在这个例子中，主线程不会阻塞，而是立即返回并...
Java并发 CompletableFuture异步编程的实现
08-25
Java并发 CompletableFuture异步编程的实现 在 Java 中，CompletableFuture 是一种异步编程的实现方式，它可以帮助开发者轻松地实现异步操作。CompletableFuture 的核心优势在于它可以将串行操作变成并行操作，从而...
CompletableFuture.zip
09-09
在Java开发中，`CompletableFuture`是Java 8引入的一个强大的工具，用于处理异步编程和并发任务。在Spring Boot框架中，它可以帮助我们优化应用性能，尤其在处理大量并发请求时。`CompletableFuture`提供了丰富的API...
CompletableFuture进阶
02-02
- CompletableFuture 在流式编程（Stream API）的优势 - CompletableFutrue实战应用之大数据商品比价 - 掌握异步任务的交互操作 - 了解get方法和join方法区别 - 掌握CompletableFuture 结合Stream API进阶应用 - ...
CompletableFuture实现的工具类
04-24
CompletableFuture实现的工具类 ，使用泛型实现各类多线程操作，满足大部分要求
javafuture源码-demo-java-completablefuture:“带有CompletableFuture的Java异步编程”
05-22
future源码Java中具有CompletableFuture的异步编程 介绍 CompletableFuture API是用于Java异步编程的高级API。 该API支持将多个异步计算流水线化（也称为链接或合并）成单个结果，而不会造成嵌套回调（“ callback ...
Java8新的异步编程方式CompletableFuture实现
08-26
Java 8 引入了一种新的异步编程工具——`CompletableFuture`，它极大地扩展了传统的`Future`接口，提供了一种更为强大的方式来处理异步任务和组合多个异步操作。`CompletableFuture`旨在解决`Future`模式的一些固有...
CompletableFuture与多线程结合使用
果酱 の 博客
05-29 5464
在Java 8中，引入了CompletableFuture类，它是Future的增强版，提供了更加灵活的异步编程方式，能够更好地利用多线程的优势。本文将详细讲解CompletableFuture的使用方法，并结合多线程实现异步编程。CompletableFuture是Java 8中新增的一个类，它实现了Future和CompletionStage接口，提供了一种更加灵活的异步编程方式。
【CompletableFuture的所有方法示例】
qq_41619801的博客
06-16 468
使用场景：当需要获取 CompletableFuture 的结果时，可以使用该方法。使用场景：当需要将一个 CompletableFuture 的结果传递给下一个阶段，并将结果合并成一个新的 CompletableFuture 对象时，可以使用该方法。使用场景：当需要在一个 CompletableFuture 的阶段完成后执行一个任务，而不需要访问阶段的结果时，可以使用该方法。使用场景：当需要将一个 CompletableFuture 的结果传递给下一个阶段，并对结果进行转换时，可以使用该方法。
Java CompletableFuture 详解
橙子wj的博客
05-21 2657
出处： http://colobu.com/2016/02/29/Java-CompletableFuture/Future是Java 5添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel方法停止任务的执行。虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

你这个代码我看不懂

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值