JAVA利用CompletableFuture优雅实现多线程的异步编排

最新推荐文章于 2024-12-20 19:44:14 发布
最新推荐文章于 2024-12-20 19:44:14 发布
阅读量1.6k 收藏 16
点赞数 26
文章标签： java 开发语言 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_81717523/article/details/142923633
版权

CompletableFuture多线程

一、CompletableFuture 介绍

CompletableFuture 是 Java 8 引入的一个类，位于 java.util.concurrent 包中。它是对 Future 接口的增强，提供了非常强大的功能来支持异步编程模型。CompletableFuture 实现了 Future 和 CompletionStage 接口，可以用来创建非阻塞代码，处理异步任务的结果，并且能够方便地进行链式调用。

主要特点

  1. 异步执行：CompletableFuture 可以异步执行任务，这意味着任务可以在另一个线程上执行，而不会阻塞当前线程。
  2. 组合性：多个 CompletableFuture 实例可以组合在一起，形成复杂的异步流程。例如，一个 CompletableFuture 的结果可以作为另一个 CompletableFuture 的输入。
  3. 回调机制：提供了多种方法来注册回调函数，这些回调函数会在未来的某个时刻（如异步操作完成时）被自动调用。
  4. 异常处理：提供了一种处理异步任务中抛出的异常的方式。

二、常用方法

说明：使用CompletableFuture异步编排大多方法都会有一个重载方法，会多出一个executor参数，用来传来自定义的线程池，如果不传就会使用默认的线程池。

1、并行执行

1.1、有返回值 supplyAsync()
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);

实例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureSupplyAsyncExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 使用默认的 ForkJoinPool.commonPool()
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "Hello from default pool";
        });

        // 使用自定义的 Executor
        ExecutorService customExecutor = Executors.newFixedThreadPool(2);
        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> { 
            return "Hello from custom pool";
        }, customExecutor);

        // 获取并打印结果，（get()这里需要处理异常，我直接抛出去了）
        System.out.println(future1.get());
        System.out.println(future2.get());

        // 关闭自定义的 Executor
        customExecutor.shutdown();
    }
}

打印：

Hello from default pool
Hello from custom pool
1.2、无返回值 runAsync()
public static CompletableFuture<Void> runAsync(Runnable runnable);
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);

2、串行执行

2.1、无入参，无返回值
// 使线程串行执行，无入参，无返回值
public CompletableFuture<Void> thenRun(Runnable action);
public CompletableFuture<Void> thenRunAsync(Runnable action);
public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor);

下面是对这三个方法的详细解释和示例。

  1. public CompletableFuture<Void> thenRun(Runnable action);
  • 描述：当 CompletableFuture 完成时，异步执行给定的 Runnable 任务。这个任务将在 CompletableFuture 完成后立即执行，但不会阻塞当前线程。
  • 执行环境：任务将在调用 thenRun 方法的线程中执行，或者在 CompletableFuture 完成时的线程中执行。
  1. public CompletableFuture<Void> thenRunAsync(Runnable action);
  • 描述：当 CompletableFuture 完成时，异步执行给定的 Runnable 任务。这个任务将在 ForkJoinPool.commonPool() 中执行。
  • 执行环境：任务将在 ForkJoinPool.commonPool() 中执行，这是一个共享的线程池。
  1. public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor);
  • 描述：当 CompletableFuture 完成时，异步执行给定的 Runnable 任务。这个任务将在指定的 Executor 中执行。
  • 执行环境：任务将在指定的 Executor 中执行，这使得你可以控制任务的执行环境，例如使用自定义的线程池或单线程执行器。

如果看不懂直接看实例吧（其实我也看不懂，哈哈哈）

实例：

package multithreading;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureThenRunExample {
    public static void main(String[] args) throws Exception {
        // 创建一个异步任务
        //myTask
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {

            for (int i = 0; i < 10; i++) {
                System.out.print("myTask ");
            }
            System.out.println();

            return "Hello, World!";
        });

        // 使用 thenRun 方法
        //Task1
        CompletableFuture<Void> thenRunFuture = future.thenRun(() -> {
            System.out.println("thenRun: Task1 completed in " + Thread.currentThread().getName());
        });

        // 使用 thenRunAsync 方法
        //Task2
        CompletableFuture<Void> thenRunAsyncFuture = future.thenRunAsync(() -> {
            System.out.println("thenRunAsync: Task2 completed in " + Thread.currentThread().getName());
        });

        // 使用 thenRunAsync 方法并指定 Executor
        //Task3
        ExecutorService customExecutor = Executors.newFixedThreadPool(2);
        CompletableFuture<Void> thenRunAsyncWithExecutorFuture = future.thenRunAsync(() -> {
            System.out.println("thenRunAsyncWithExecutor: Task3 completed in " + Thread.currentThread().getName());
        }, customExecutor);

        // 等待所有任务完成
        thenRunFuture.get();
        thenRunAsyncFuture.get();
        thenRunAsyncWithExecutorFuture.get();

        // 关闭自定义的 Executor
        customExecutor.shutdown();
    }
}

打印：

myTask myTask myTask myTask myTask myTask myTask myTask myTask myTask 
thenRunAsync: Task2 completed in ForkJoinPool.commonPool-worker-2
thenRun: Task1 completed in ForkJoinPool.commonPool-worker-1
thenRunAsyncWithExecutor: Task3 completed in pool-1-thread-1

由此可见：

当执行完supplyAsync之后才会并行执行thenRun和thenRunAsync方法，而且supplyAsync只会执行一次。而且thenRun和thenRunAsync共用默认线程池。

2.2、有入参，无返回值
// 使线程串行执行，有入参，无返回值
public CompletableFuture<Void> thenAccept(Consumer<? super T> action);
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletableFuture<Void> thenAcceptAsync(Consumer<? super T> action, Executor executor);

实例：

package multithreading;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureThenAcceptExample {
    public static void main(String[] args) throws Exception {
        // 创建一个异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Hello, World!";
        });

        // 使用 thenAccept 方法
        CompletableFuture<Void> thenAcceptFuture = future.thenAccept(result -> {
            System.out.println("thenAccept: Result is " + result + " in " + Thread.currentThread().getName());
        });

        // 使用 thenAcceptAsync 方法
        CompletableFuture<Void> thenAcceptAsyncFuture = future.thenAcceptAsync(result -> {
            System.out.println("thenAcceptAsync: Result is " + result + " in " + Thread.currentThread().getName());
        });

        // 使用 thenAcceptAsync 方法并指定 Executor
        ExecutorService customExecutor = Executors.newFixedThreadPool(2);
        CompletableFuture<Void> thenAcceptAsyncWithExecutorFuture = future.thenAcceptAsync(result -> {
            System.out.println("thenAcceptAsyncWithExecutor: Result is " + result + " in " + Thread.currentThread().getName());
        }, customExecutor);

        // 等待所有任务完成
        thenAcceptFuture.get();
        thenAcceptAsyncFuture.get();
        thenAcceptAsyncWithExecutorFuture.get();

        // 关闭自定义的 Executor
        customExecutor.shutdown();
    }
}

打印：

thenAccept: Result is Hello, World! in main
thenAcceptAsync: Result is Hello, World! in ForkJoinPool.commonPool-worker-1
thenAcceptAsyncWithExecutor: Result is Hello, World! in pool-1-thread-1

解释：supplyAsync() 的返回结果可以通过 thenAccept(result ->{}) 的 result 传递到串行线程。

2.3、有入参，有返回值
// 使线程串行执行，有入参，有返回值
public <U> CompletableFuture<U> thenApply(Function<? super T,? extends U> fn);
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn);
public <U> CompletableFuture<U> thenApplyAsync(Function<? super T,? extends U> fn, Executor executor);

实例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureThenApplyExample {
    public static void main(String[] args) throws Exception {
        // 创建一个异步任务
        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "Hello, World!";
        });

        // 使用 thenApply 方法
        CompletableFuture<Integer> thenApplyFuture = future.thenApply(result -> {
            System.out.println("thenApply: Result is " + result + " in " + Thread.currentThread().getName());
            return result.length();
        });

        // 使用 thenApplyAsync 方法
        CompletableFuture<Integer> thenApplyAsyncFuture = future.thenApplyAsync(result -> {
            System.out.println("thenApplyAsync: Result is " + result + " in " + Thread.currentThread().getName());
            return result.length();
        });

        // 使用 thenApplyAsync 方法并指定 Executor
        ExecutorService customExecutor = Executors.newFixedThreadPool(2);
        CompletableFuture<Integer> thenApplyAsyncWithExecutorFuture = future.thenApplyAsync(result -> {
            System.out.println("thenApplyAsyncWithExecutor: Result is " + result + " in " + Thread.currentThread().getName());
            return result.length();
        }, customExecutor);

        // 等待所有任务完成并获取结果
        int length1 = thenApplyFuture.get();
        int length2 = thenApplyAsyncFuture.get();
        int length3 = thenApplyAsyncWithExecutorFuture.get();

        System.out.println("Length from thenApply: " + length1);
        System.out.println("Length from thenApplyAsync: " + length2);
        System.out.println("Length from thenApplyAsyncWithExecutor: " + length3);

        // 关闭自定义的 Executor
        customExecutor.shutdown();
    }
}

打印

thenApply: Result is Hello, World! in ForkJoinPool.commonPool-worker-1
thenApplyAsyncWithExecutor: Result is Hello, World! in pool-1-thread-1
thenApplyAsync: Result is Hello, World! in ForkJoinPool.commonPool-worker-2
Length from thenApply: 13
Length from thenApplyAsync: 13
Length from thenApplyAsyncWithExecutor: 13

3、等待所有任务完成

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs);

实例：

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;

public class CompletableFutureAllOfExample {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 创建三个异步任务
        CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> {
            return "Task 1";
        });

        CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> {
            return "Task 2";
        });

        CompletableFuture<String> future3 = CompletableFuture.supplyAsync(() -> {
            return "Task 3";
        });

        // 使用 allOf 等待所有任务完成
        CompletableFuture<Void> allFutures = CompletableFuture.allOf(future2, future1, future3);

        // 等待 allOf 返回的 CompletableFuture 完成
        allFutures.get();

        // 打印每个任务的结果
        System.out.println("Task 1 result: " + future1.join());
        System.out.println("Task 2 result: " + future2.join());
        System.out.println("Task 3 result: " + future3.join());
    }
}

打印：

Task 1 result: Task 1
Task 2 result: Task 2
Task 3 result: Task 3

说明：会等待CompletableFuture. allOf 传入的线程会执行完，才继续往下执行代码

二、关于异常处理

1、使用 exceptionally方法:
  • public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn);
  • 如果之前的阶段因为异常而完成，那么 exceptionally 方法提供的函数会被调用，并且可以返回一个替代的结果或处理异常。例如：
CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Error");
}).exceptionally(ex -> {
    System.out.println("Caught exception: " + ex.getMessage());
    return null; // 返回一个默认值
});
2、使用 handle方法
  • public <U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
  • 不管前面的阶段是否正常完成还是因为异常而完成，handle 方法都会被调用。这使得你可以同时处理结果和异常。例如：
CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Error");
}).handle((result, ex) -> {
    if (ex != null) {
        System.out.println("Caught exception: " + ex.getMessage());
        return null; // 返回一个默认值
    } else {
        return result;
    }
});
3、使用 whenComplete方法
CompletableFuture.supplyAsync(() -> {
    throw new RuntimeException("Error");
}).whenComplete((result, ex) -> {
    if (ex != null) {
        System.out.println("Caught exception: " + ex.getMessage());
    } else {
        System.out.println("Result: " + result);
    }
});
4、使用 completeExceptionally方法
  • public boolean completeExceptionally(Throwable ex);
  • 这个方法允许你手动地将一个异常与 CompletableFuture 关联起来。这通常用于模拟错误情况或在特定条件下提前完成未来。
5、链式调用
  • 当多个 CompletableFuture 被链式调用时（如 thenApply, thenAccept, thenRun 等），如果任何一步抛出异常，那么后续的步骤将不会被执行，除非它们是通过 exceptionally 或 handle 方法定义的。

以上就是 CompletableFuture 对异常处理的主要方法。正确地处理异常对于确保应用程序的健壮性和可靠性至关重要，尤其是在进行异步编程时。

CompletableFuture实现异步编排全面分析和总结
m0_71777195的博客
03-14 569
结合了Future的优点，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合的方法。被设计在Java中进行异步编程。异步编程意味着在主线程之外创建一个独立的线程，与主线程分隔开，并在上面运行一个非阻塞的任务，然后通知主线程进展，成功或者失败。是由Java8引入的，在Java8之前我们一般通过Future实现异步。Future。
Java 之 异步 CompletableFuture
weixin_44513658的博客
05-04 1270
java 异步 CompletableFuture 上手
CompletableFuture执行多个异步任务,将结果合并返回
热门推荐
悟能的师兄的专栏
04-10 1万+
Java CompletableFuture执行多个异步任务,将结果合并返回
Java异步编程利器：CompletableFuture实战
最新发布
CoderJia的学习之路
12-20 964
在现代 Java 应用程序开发中，异步编程已经成为提升系统性能和用户体验的重要手段。CompletableFuture 作为 Java 8 引入的异步编程工具，不仅提供了 Future 接口的增强版本，还支持函数式编程，使得异步任务的编排和组合变得更加灵活和直观。本文将深入探讨 CompletableFuture 的各种应用场景，帮助你更好地掌握这个强大的工具。
异步编程还在用Future？快来学习下CompletableFuture超级详细
asoklove的专栏
06-05 205
环境：Java8 Future基本应用 Future是从JDK1.5开始有的，目的是获取异步任务执行的结果，通常情况会结合ExecutorService及Callable一起使用。 1、Future结合Callable使用 单任务执行 private static class Task implements Callable<String> { @Override public String call() throws Exception { TimeUnit.SE
Java8 CompletableFuture处理多个异步任务
一生编程，快乐编程
09-11 893
thenAcceptBoth()： 同样将两个任务(CompletableFuture)的执行结果作为方法入参，但是是个Void的返回值，相当于没有返回值；runAfterBoth()： 在两个任务(CompletableFuture)之后执行，但没有入参，而且是个Void的返回值，相当于没有返回值。thenRun()： 根本不关心一个任务的前一阶段的输出，它只负责运行新的Runnable任务，该方法返回值类型为Void，相当于没有返回值。还有两个参数，第一个参数是任务的返回值，第二个参数是异常。
Java并发编程—CompletableFuture的异步执行案例
小魏快起床的博客
12-06 1220
临近过年了，很多铁子都有购物的需求，那么大家肯定想花更少的钱去买相同的一个产品，例如茅台酒在不同的购物平台或者不同的商家里面价格是不一样的，例如：🍕jd：🍕tb： 图中这些价格都是不一样的，所以大家就会有一个需求，能不能把这个当作一个程序进行一个数据统计，统计出不同平台的茅台价格，然后自己根据价格、商家来购买，这个例子大家都明白，其实在工作中也有很多这种的需求，那么针对这种需要统计的需求业务我们该怎么去做呢？ 相信很多铁子有心里有方案： 🍄2、业务开始前还需要实例化几个具
CompletableFuture 执行异步任务
weixin_46685542的博客
10-11 2085
CompletableFuture 执行异步任务
Java 异步编程——异步编排(CompletableFuture)
longool的博客
10-21 1310
CompletableFuture 是 JDK8 提出的一个支持非阻塞的多功能的 Future，提供了一种强大的异步编程模型，实现了 Future 接口；在使用 Future 的过程中，大家会发现 Future 有两种方式返回结果的方式CompletableFuture 接口提供了非常多的方法用于编排异步任务，基本每个方法都有两套实现，Async 版本的函数与非 Async 版本的函数。
Springboot利用CompletableFuture异步执行线程（有回调和无回调）
weixin_42966151的博客
10-12 6699
项目中总会有需要异步执行来避免浪费时间资源的情况，这就需要异步操作。异步又分两种： 1、无回调：有一些执行过程对用户而言不需要反馈回调，只需要自己执行即可，且执行过程时间较长（某些第三方接口，如发送短信验证码、查取ip属地等等），如果同步执行，势必会影响到用户体验，这时候就可以使用CompletableFuture.runAsync()方法了。 2、有回调：在执行异步操作结束后，需要获得异步方法返回的值，然后再回调给用户展示，这时候就需要用到CompletableFuture.supplyAsync()
Java CompletableFuture异步编程
Hanhahahahah的博客
08-25 244
Java CompletableFuture从Future到CompletableFuture 从Future到CompletableFuture Java的Future机制详解 常见的两种创建线程的方式。一种是直接继承Thread，另外一种就是实现Runnable接口。 这两种方式都有一个缺陷就是：在执行完任务之后无法获取执行结果 Future模式的核心思想是能够让主线程将原来需要同步等待的这段时间用来做其他的事情。（因为可以异步获得执行结果，所以不用一直同步等待去获得执行结果） B图表达的是使用Futu
Java8新的异步编程方式CompletableFuture实现
08-26
主要介绍了Java8新的异步编程方式CompletableFuture实现，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Java CompletableFuture实现多线程异步编排
jh035的博客
11-20 1136
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。
CompletableFuture实现多线程异步任务编排
sinat_31583645的博客
02-24 1447
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。CompletableFuture和FutureTask同属于Future接口。
Java多线程【异步编排】
大脑不能为空
10-13 4071
Java线程和进程的区别，为什么要有线程池，JUC并发编程教程。
JAVA中使用CompletableFuture进行异步编程
YIYIYI
09-27 898
JAVA中使用CompletableFuture进行异步编程
CompletableFuture异步编程详细使用教程
爱学习的软件开发的博客
04-29 1784
CompletableFuture是Java 8提供的一种新的编写异步任务的方式，它是一个受检查的异步任务的执行器。它支持多个任务的编排，并提供了用于检查任务执行状态以及支持完成时的回调接口的机制。通过使用CompletableFuture，程序员可以更加灵活地组织异步任务，减少代码量，从而提高程序的性能和效率。
使用CompletableFuture异步编程在java代码中实现异步操作
NewBeeMu的博客
04-08 1686
通常来说，实现异步操作可以通过使用RabbitMQ等中间件来实现，但是使用CompletableFuture异步变成其实不需要这个麻烦，只需要简单几行代码就可以实现 以最简单的线程休眠2秒为例 首先是普通的java代码 public class test02 { public static void main(String[] args) { try { Thread.sleep(2000); System.out.println("b
CompletableFuture实现多线程异步超时处理
07-20
CompletableFuture 是 Java 8 引入的一个类，用于实现多线程的异步编程。它提供了丰富的方法来处理异步任务的结果、组合多个异步任务以及处理异常情况。 要实现超时处理，你可以结合 CompletableFuture 的方法和 Java 的 ScheduledExecutorService 来实现。下面是一个示例： ```java import java.util.concurrent.CompletableFuture; import java.util.concurrent.ExecutionException; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class CompletableFutureTimeoutExample { public static void main(String[] args) { // 创建一个 ScheduledExecutorService 用于超时处理 ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1); // 创建一个 CompletableFuture 对象 CompletableFuture<String> future = new CompletableFuture<>(); // 设置超时时间 long timeout = 5000; // 5秒 // 在指定时间后取消 CompletableFuture executorService.schedule(() -> { if (!future.isDone()) { future.completeExceptionally(new TimeoutException("Timeout")); } }, timeout, TimeUnit.MILLISECONDS); // 异步任务 CompletableFuture.runAsync(() -> { try { // 执行异步操作，例如网络请求、数据库查询等 String result = performAsyncTask(); // 当任务完成时，设置结果给 CompletableFuture future.complete(result); } catch (Exception e) { future.completeExceptionally(e); } }); // 获取结果或处理超时异常 try { String result = future.get(); // 处理成功结果 } catch (TimeoutException e) { // 处理超时异常 } catch (InterruptedException | ExecutionException e) { // 处理其他异常 } // 关闭 ScheduledExecutorService executorService.shutdown(); } private static String performAsyncTask() { // 执行异步任务的逻辑 return "Async task result"; } } ``` 在上面的示例中，我们创建了一个 CompletableFuture 对象，并使用 ScheduledExecutorService 在指定的超时时间后取消 CompletableFuture。然后，我们使用 CompletableFuture.runAsync 方法执行异步任务，并在任务完成时设置结果给 CompletableFuture。最后，我们使用 future.get() 方法来获取结果或处理超时异常。 希望以上信息能够帮助到你！如果你还有其他问题，请随时提问。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值