CompletableFuture 异步编排使用详解

已于 2023-09-21 08:51:29 修改
阅读量805 收藏 13
点赞数 1
分类专栏： java 文章标签： java 开发语言
于 2023-02-15 16:22:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_art_xiang/article/details/129043374
版权

文章目录

写在前面

在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。

而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。

CompletableFuture 和 FutureTask 同属于 Future 接口的实现类，都可以获取线程的执行结果。
在这里插入图片描述

CompletableFuture的使用

1、创建 CompletableFuture 对象

CompletableFuture 提供了四个静态方法来创建一个异步操作。

// API方法列表
public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

其中runAsync都是没有返回结果的，supplyAsync都是可以获取返回结果的；可以传入自定义的线程池，否则就用默认的线程池。

默认情况下 CompletableFuture 会使用公共的 ForkJoinPool 线程池，这个线程池默认创建的线程数是 CPU 的核数（也可以通过 JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism 来设置 ForkJoinPool 线程池的线程数）。如果所有 CompletableFuture 共享一个线程池，那么一旦有任务执行一些很慢的 I/O 操作，就会导致线程池中所有线程都阻塞在 I/O 操作上，从而造成线程饥饿，进而影响整个系统的性能。所以，强烈建议你要根据不同的业务类型创建不同的线程池，以避免互相干扰。

代码实例

CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getName());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
}, executor);

System.out.println("main......start.....");
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, executor);
Integer integer = future.get(); // 阻塞，直到处理完毕
System.out.println("main......end....." + future.get());

2、获取结果

获取结果有五种方式：
get() 方法一直阻塞，直到线程执行完成并将结果直接获取。
get(long timeout, TimeUnit unit) 可以指定等待的时间，如果等待时间内未获取到结果，就抛TimeoutException异常。
join() 方法与get()方法相同，也是阻塞，等待获取结果，但是join方法不需要额外处理get()方法受检查的异常。
getNow(T valueIfAbsent) 方法，表示立即获取结果，如果还没处理完，就返回一个默认结果。
complete(T value) 方法，表示立即获取结果，如果没有执行完成就立即中断线程并返回默认结果，返回值为是否打断线程。

CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
    //暂停几秒钟线程
    try {
        TimeUnit.SECONDS.sleep(1);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return "abc";
});

System.out.println(completableFuture.get());
System.out.println(completableFuture.get(2L,TimeUnit.SECONDS));
System.out.println(completableFuture.join());

//暂停几秒钟线程
//try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) { e.printStackTrace(); }

System.out.println(completableFuture.getNow("xxx"));
System.out.println(completableFuture.complete("completeValue")+"\t"+completableFuture.get());

3、异常处理

whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况。

whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync：是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。
也就是说，方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

exceptionally() 的使用非常类似于 try{}catch{}中的 catch{}，但是由于支持链式编程方式，所以相对更简单。

whenComplete() 和 handle() 系列方法就类似于 try{}finally{}中的 finally{}，无论是否发生异常都会执行 whenComplete() 中的回调函数 consumer 和 handle() 中的回调函数 fn。whenComplete() 和 handle() 的区别在于 whenComplete() 不支持修改返回结果，而 handle() 是支持修改返回结果的。

// API方法列表
public CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor)
public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)

代码实例

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).whenComplete((res,exception) -> {
    //虽然能得到异常信息，但是没法修改返回数据
    System.out.println("异步任务成功完成了...结果是：" + res + "异常是：" + exception);
}).exceptionally(throwable -> {
    //可以感知异常，同时返回默认值
    return 10;
});

CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 0;
    System.out.println("运行结果：" + i);
    return i;
}, executor).handle((result,thr) -> {
	// 可以获取结果、获取异常、设置返回值
    if (result != null) {
        return result * 2;
    }
    if (thr != null) {
        System.out.println("异步任务成功完成了...结果是：" + result + "异常是：" + thr);
        return 0;
    }
    return 0;
});

ExecutorService threadPool = Executors.newFixedThreadPool(3);

CompletableFuture.supplyAsync(() ->{
    //暂停几秒钟线程
    try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); }
    System.out.println("111");
    return 1;
},threadPool).handle((f,e) -> {
    int i=10/0;
    System.out.println("222");
    return f + 2;
}).handle((f,e) -> {
    System.out.println("333");
    return f + 3;
}).whenComplete((v,e) -> {
    if (e == null) {
        System.out.println("----计算结果： "+v);
    }
}).exceptionally(e -> {
    e.printStackTrace();
    System.out.println(e.getMessage());
    return null;
});

System.out.println(Thread.currentThread().getName()+"----主线程先去忙其它任务");

threadPool.shutdown();

4、线程串行化处理

// API方法列表
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)

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)

public CompletableFuture<Void> thenRun(Runnable action)
public CompletableFuture<Void> thenRunAsync(Runnable action)
public CompletableFuture<Void> thenRunAsync(Runnable action, Executor executor)

thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。
thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
thenRun 方法：只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行thenRun 的后续操作，获取不到上一个任务的返回值。

带有 Async 默认是异步执行的。同之前。
以上都要前置任务成功完成，所以这些方法都是对线程进行串行处理的。

代码实例

CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, executor).thenRunAsync(() -> {
    System.out.println("任务2启动了，但是无法接收上一个任务的返回值");
}, executor).thenApplyAsync(res -> {
    System.out.println("任务3启动了...上一个任务返回值是" + res);
    return "Hello" + res;
}, executor).thenAcceptAsync(res -> {
    System.out.println("任务4启动了...上一个任务返回值是" + res);
}, executor);

ExecutorService threadPool = Executors.newFixedThreadPool(5);
try
{
    CompletableFuture<Void> completableFuture = CompletableFuture.supplyAsync(() -> {
        try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("1号任务" + "\t" + Thread.currentThread().getName());
        return "abcd";
    },threadPool).thenRunAsync(() -> { // 切换线程执行
        try { TimeUnit.MILLISECONDS.sleep(20); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("2号任务" + "\t" + Thread.currentThread().getName());
    }).thenRun(() -> { // 当前线程执行
        try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("3号任务" + "\t" + Thread.currentThread().getName());
    }).thenRun(() -> { // 当前线程执行
        try { TimeUnit.MILLISECONDS.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("4号任务" + "\t" + Thread.currentThread().getName());
    });
    System.out.println(completableFuture.get(2L, TimeUnit.SECONDS));
}catch (Exception e){
    e.printStackTrace();
}finally {
    threadPool.shutdown();
}

5、两任务组合 之 都要完成（And关系）

两个任务必须都完成，触发该任务。
thenCombine：组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值。
thenAcceptBoth：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。
runAfterBoth：组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，处理该任务，无法获取两个任务的返回值，也没有自身的返回值。

// API方法列表
public CompletableFuture<Void> runAfterBoth(CompletionStage<?> other,
                                            Runnable action)
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,
                                                 Runnable action)
public CompletableFuture<Void> runAfterBothAsync(CompletionStage<?> other,
                                                 Runnable action,
                                                 Executor executor)

public <U> CompletableFuture<Void> thenAcceptBoth(
    CompletionStage<? extends U> other,
    BiConsumer<? super T, ? super U> action)
public <U> CompletableFuture<Void> thenAcceptBothAsync(
    CompletionStage<? extends U> other,
    BiConsumer<? super T, ? super U> action)
public <U> CompletableFuture<Void> thenAcceptBothAsync(
    CompletionStage<? extends U> other,
    BiConsumer<? super T, ? super U> action, Executor executor)

public <U,V> CompletableFuture<V> thenCombine(
    CompletionStage<? extends U> other,
    BiFunction<? super T,? super U,? extends V> fn)
public <U,V> CompletableFuture<V> thenCombineAsync(
    CompletionStage<? extends U> other,
    BiFunction<? super T,? super U,? extends V> fn)
public <U,V> CompletableFuture<V> thenCombineAsync(
    CompletionStage<? extends U> other,
    BiFunction<? super T,? super U,? extends V> fn, Executor executor)

代码实例

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1开始");
    return 1;
}, executor);

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2开始");
    return 2;
}, executor);

// 无法获取上两个任务返回值，也无自身返回值
future1.runAfterBothAsync(future2,() -> {
    System.out.println("任务3开始");
} ,executor);

// 可以获取上两个任务返回值，但是自身无返回值
future1.thenAcceptBothAsync(future2,(f1, f2) -> {
    System.out.println("任务3开始，获取f1的返回值为" + f1 + "获取f2返回值为" + f2);
} , executor);

// 可以获取上两个任务返回值，自身也有返回值
future1.thenCombineAsync(future2,(f1, f2) -> {
    System.out.println("任务3开始，获取f1的返回值为" + f1 + "获取f2返回值为" + f2);
    return 3;
} ,executor);

6、两任务组合 之 一个完成（Or关系）

当两个任务中，任意一个 future 任务完成的时候，执行任务。

applyToEither：两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返回值。

// API方法列表
public <U> CompletableFuture<U> applyToEither(
    CompletionStage<? extends T> other, Function<? super T, U> fn)
public <U> CompletableFuture<U> applyToEitherAsync(
    CompletionStage<? extends T> other, Function<? super T, U> fn)
public <U> CompletableFuture<U> applyToEitherAsync(
    CompletionStage<? extends T> other, Function<? super T, U> fn,
    Executor executor)

public CompletableFuture<Void> acceptEither(
    CompletionStage<? extends T> other, Consumer<? super T> action)
public CompletableFuture<Void> acceptEitherAsync(
    CompletionStage<? extends T> other, Consumer<? super T> action)
public CompletableFuture<Void> acceptEitherAsync(
    CompletionStage<? extends T> other, Consumer<? super T> action,
    Executor executor)

public CompletableFuture<Void> runAfterEither(CompletionStage<?> other,
                                              Runnable action)
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,
                                                   Runnable action)
public CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,
                                                   Runnable action,
                                                   Executor executor)

代码实例

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1开始");
    return 1;
}, executor);

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2开始");
    return 2;
}, executor);

// 无法获取上个任务返回值，也无自身返回值
future1.runAfterEitherAsync(future2,() -> {
    System.out.println("任务3开始");
} ,executor);

// 可以获取上个任务返回值，但是自身无返回值
future1.acceptEitherAsync(future2,(res) -> {
    System.out.println("任务3开始，获取的返回值为" + res);
} , executor);

// 可以获取上个任务返回值，自身也有返回值
future1.applyToEitherAsync(future2,(res) -> {
    System.out.println("任务3开始，获取的返回值为" + res);
    return 3;
} ,executor);

7、多任务组合

allOf：等待所有任务完成
anyOf：只要有一个任务完成

// API方法列表
public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)
public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)

代码实例

CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务1开始");
    return 1;
}, executor);

CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务2开始");
    return 2;
}, executor);

CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("任务3开始");
    return 3;
}, executor);

// allOf：等待所有任务完成
CompletableFuture<Void> voidCompletableFuture = CompletableFuture.allOf(future1, future2, future3);
voidCompletableFuture.get();// 等待所有结果完成，不用每一个都get()

// anyOf：只要有一个任务完成，可以拿到返回值
CompletableFuture<Object> voidCompletableFuture = CompletableFuture.anyOf(future1, future2, future3);
voidCompletableFuture.get();

总结

Java 语言开始官方支持异步编程：在 1.8 版本提供了 CompletableFuture，在 Java 9 版本则提供了更加完备的 Flow API，异步编程目前已经完全工业化。因此，学好异步编程还是很有必要的。

CompletableFuture 已经能够满足简单的异步编程需求，如果对异步编程感兴趣，可以重点关注 RxJava 这个项目，利用 RxJava，即便在 Java 1.6 版本也能享受异步编程的乐趣。

Java并发 CompletableFuture异步编程的实现
08-25
使用 CompletableFuture 可以简化异步编程的实现，并且代码更加简洁、易读。 CompletableFuture 的使用方法有多种，例如使用 runAsync 方法和 supplyAsync 方法来创建 CompletableFuture 对象。runAsync 方法用于...
玩转CompletableFuture线程异步编排，看这一篇就够了
热门推荐
__Forward
11-15 1万+
1、CompletableFuture介绍 CompletableFuture可用于线程异步编排，使原本串行执行的代码，变为并行执行，提高代码执行速度。 学习异步编排先需要学习线程池和lambda表达式相关知识，学习线程池可以移步我的另一篇博客 ThreadPoolExecutor线程池理解 2、CompletableFuture使用 说明：使用CompletableFuture异步编排大多方法都会有一个重载方法，会多出一个executor参数，用来传来自定义的线程池，如果不传就会使用默认的线程池。 下文举
【机试题】CompletableFuture编排
ThinkPet
11-10 170
使用CompletableFuture编排 AService.get()、BService.get()、CService.get(int i) （ABC三个服务返回结果都是int），满足使用A、B的结果相加，再作为参数传给C，取得C的结果后乘以 100 后返回。2.处理异常情况，异常情况返回0。
完全！易懂！看这篇就够啦！CompletableFuture使用教程，Java异步编程的利器！
最新发布
qq_52462620的博客
08-13 1940
完全！易懂！看这篇就够啦！CompletableFuture使用教程，Java异步编程的利器！涵盖12+方法的介绍，覆盖日常所用的大部分方法。不仅介绍方法，还有提问；不仅介绍如何使用，还介绍为什么这样使用。让你深入理解异步到底是由哪一个线程来执行！
CompletableFuture异步任务编排用法和详解
endwas
10-31 1534
在工作中，常常会调用多个服务或者方法去获取不同的数据，如果传统做法就是串行一个个获取，然后封装返回。我们可以尝试使用CompletableFuture，将多个操作交给异步线程执行，然后主线程等待最长任务完成，将所有结果一并返回即可。 Future局限性 当我们得到包含结果的Future时，我们可以使用get方法等待线程完成并获取返回值，但我们都知道future.get()是阻塞的方法，会一直等到线程执行完毕拿到返回值。我们可以看到FutureTask中的get方法，就是循环代码直到线程执行完成返回。 .
编写一个Java函数，通过调用AService.get()、BService.get()、CService.get()三个接口，获取三个整数，然后将这三个整数累加，最终返回累加的值
qq_21277357的博客
10-25 1396
【代码】编写一个Java函数，通过调用AService.get()、BService.get()、CService.get()三个接口，获取三个整数，然后将这三个整数累加，最终返回累加的值。
CompletableFuture使用详解（全网看这一篇就行）
星哲最开心
07-31 8089
CompletableFuture使用详解（全网看这一篇就行）
CompletableFuture 异步处理
07-16
以下是一个简单的CompletableFuture使用示例，展示如何异步执行任务并处理结果： ```java Supplier<String> task = () -> { Thread.sleep(2000); // 模拟耗时操作 return "Task Result"; }; CompletableFuture...
Vue异步组件使用详解
08-30
2. **使用异步组件的前提** 建议使用webpack作为构建工具，因为webpack原生支持代码分割功能，可以方便地将组件代码分割为单独的chunk，实现异步加载。Browserify默认不支持这种特性，但可以通过插件实现。 3. **...
SpringBoot异步任务使用方法详解
08-19
SpringBoot异步任务使用方法详解 SpringBoot异步任务使用方法详解是基于Java的SpringBoot框架中的一种异步任务处理机制。该机制允许开发者在SpringBoot应用程序中执行异步任务，以提高应用程序的性能和响应速度。 ...
CompletableFuture基本使用
工作记录
04-02 3746
CompletableFuture是什么 CompletableFuture是Java8中提供的Future的扩展功能，帮助我们简化异步编程的复杂性，引入函数式编程，通过回调的方式处理计算结果，也提供了转换和组合的方法。 它可能代表一个明确完成的Future，也有可能代表一个完成阶段（ CompletionStage ），它支持在计算完成以后触发一些函数或执行某些动作。 它实现了Future和CompletionStage接口 借助CompletionStage的方法可以实现链式调用 一个Comp
异步编程：CompletableFuture详解使用
勿扰博客
12-06 825
一、创建异步任务 二、异步回调 三、组合处理 CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步回调、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。
CompletableFuture多任务执行及简单使用场景
来都来了
06-30 5251
CompletableFuture多任务执行
CompletableFuture异步编排
qq_21238011的博客
06-13 118
传入一个自定义的线程池时 如果执行的第一个任务的时候调用thenRun方法执行第二个任务，则第二个任务和第一个任务使用的是同一个线程池。如果调用thenRunAsync执行第二个任务时，则第一个 任务使用的是自定义线程池，第二个 任务还是使用的默认的线程池。定义了操作异步任务执行的一些方法，比如获取异步任务的执行结果 取消任务的执行 判断任务是否被i取消 判断任务执行是否完成。一个阶段的执行可能被单个阶段的完成触发 也可能有多个阶段一起触发。异步执行任务的三个特点 多线程 有返回结果 异步任务。
CompletableFuture使用详解
秃头的博客
08-22 1781
runAsync()、exceptionally()、whenComplete()、handle()、thenRun()、thenAccept()、thenApply()、thenCompose()、thenComposeAsync()、runAfterBoth()、runAfterBothAsync()、thenAcceptBoth()、thenCombine()、runAfterEither()、acceptEither()、applyToEither()、anyOf()、allOf()
CompletableFuture使用详解（超详细）
javaeEEse的博客
02-20 1万+
CompletableFuture就是帮你处理这些任务之间的逻辑关系，编排好任务的执行方式后，任务会按照规划好的方式一步一步执行，不需要让业务线程去频繁的等待。 比如说任务A，任务B，还有任务C。其中任务B还有任务C执行的前提是任务A先完成，再执行任务B和任务C。
CompletableFuture使用（全网最详细！！！）
国家专精特新小巨人、资深消防行业企业、国家高新技术企业、智慧消防技术实验室、准独角兽企业、浙江省电流AI技术研发中心
06-26 5444
前言普通情况下，我们的接口逻辑都是串行化的，有时候在我们方法中可能存在着非常耗时的操作这样就会造成代码阻塞，但是呢，为了用户的体验，我们可能需要将一些复杂的数据开启线程进行异步处理。所谓异步，其实就是实现一个可无需等待被调用函数的返回值而让操作继续运行的方法，简单的讲就是另启一个线程来完成调用中的部分计算，使调用继续运行或返回，而不需要等待计算结果。Java8 提供的可以自定义线程池或使用默认线程池对数据进行异步处理，且可以根据需求选择是否返回异步结果！灵活的使用。
CompletableFuture实现异步编排全面分析和总结
蓝天⊙白云的博客
03-22 324
异步回调方法可以选择是否传递线程池参数Executor，这里为了实现线程池隔离，当不传递线程池时，默认会使用ForkJoinPool中的公共线程池CommonPool，这个线程池默认创建的线程数是CPU的核数，如果所有的异步回调共享一个线程池，核心与非核心业务都竞争同一个池中的线程，那么一旦有任务执行一些很慢的I/O 操作，就会导致线程池中所有线程都阻塞在I/O操作上，很容易成为系统瓶颈，影响整个系统的性能。因此， 建议强制传线程池，且根据实际情况做线程池隔离，减少不同业务之间的相互干扰。
completablefuture 异步编排
07-19
CompletableFuture 是 Java 8 中引入的一个强大的工具，用于处理异步计算任务。它是一个代表最终完成结果的对象，可以表示一个计算过程是否已经完成、成功还是失败，并提供了一系列方法来进行异步操作的串联、并行和错误处理。 1. **链式调用**：CompletableFuture 提供了 `.thenApply()`, `.thenAccept()`, 和 `.thenCompose()` 等方法，允许程序员通过链式调用的方式将多个异步操作串联起来，形成一个任务序列。 2. **并发处理**：你可以使用 `.thenRun()`, `.thenCombine()`, 或者 `.parallel()` 等方法并发地执行多个Future，提高效率。 3. **异常管理**：当其中一个阶段抛出异常时，可以通过 `.exceptionally()` 方法捕获并处理这个异常，而不会影响整个链条的其他部分。 4. **回退值**：如果一个阶段未能完成，后续的 `.thenApply()`, `.thenAccept()` 可以接收并处理这个未完成的结果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

秃了也弱了。

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

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

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

打赏作者

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

抵扣说明：

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

余额充值