CompletableFuture使用详解

已于 2022-08-22 21:09:55 修改
阅读量1.6k 收藏 11
点赞数
分类专栏： 多线程与锁 文章标签： java
于 2022-08-22 16:50:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42764269/article/details/126429634
版权

CompletableFuture是对Future的扩展和增强。CompletableFuture实现了Future接口，并在此基础上进行了丰富的扩展，完美弥补了Future的局限性，同时CompletableFuture实现了对任务编排的能力。借助这项能力，可以轻松地组织不同任务的运行顺序、规则以及方式。从某种程度上说，这项能力是它的核心能力。而在以往，虽然通过CountDownLatch等工具类也可以实现任务的编排，但需要复杂的逻辑处理，不仅耗费精力且难以维护。

CompletableFuture的继承结构如下：
在这里插入图片描述

CompletionStage接口定义了任务编排的方法，执行某一阶段，可以向下执行后续阶段。异步执行的，默认线程池是ForkJoinPool.commonPool()，但为了业务之间互不影响，且便于定位问题，强烈推荐使用自定义线程池。

1、创建异步操作

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

//以Runnable函数式接口类型为参数，没有返回结果
public static CompletableFuture<Void> runAsync(Runnable runnable);
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor);
//以Supplier函数式接口类型为参数，返回结果类型为U
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier);
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor);

这四个方法的区别：

runAsync()：以Runnable函数式接口类型为参数，没有返回结果。

supplyAsync()：以Supplier函数式接口类型为参数，返回结果类型为U；Supplier接口的 get()是有返回值的(会阻塞)。

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

2、结果处理

方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行)。

//当异步任务发生异常的时触发此方法，可以用来返回一个默认值
CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn);

//当异步任务完成(不管是正常完成还是异常完成都会触发)之后触发，可以用来进行后续操作，无法修改返回值
CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action)
CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action);
CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T, ? super Throwable> action, Executor executor);

//当异步任务完成(不管是正常完成还是异常完成都会触发)之后触发，如果是异常完成(异步任务的结果如果为 null则发生异常，否则为正常完成)可以用来返回默认值；如果是正常完成可以用来进行后续操作，并返回结果。
<U> CompletableFuture<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
<U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
<U> CompletableFuture<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor);

exceptionally()

一般与whenComplete()配合使用，异常捕获范围包含前面的所有异步线程

具体使用：

final CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
     System.out.println("当前线程号：" + Thread.currentThread().getId());
     int i = 10 / 0;
     System.out.println("运行结果：" + i);
     return i;
 }, threadPool).exceptionally(excption -> {
 	 //可以感知异常，同时返回默认数据
     System.out.println("执行发生异常，返回默认数据，异常信息为：" + excption);
     return 10;
 });
 System.out.println("执行结果为："+future.get());

执行结果：

当前线程号：20
执行发生异常，返回默认数据，异常信息为：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
执行结果为：10

whenComplete()

一般与exceptionally()配合使用，获取前一个异步线程的结果和异常

具体使用：

final CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, threadPool).whenCompleteAsync((res,excption) -> {
    //虽然能得到异常信息，但是没法修改返回数据
    System.out.println("异步任务成功执行....结果是："+res+",异常是："+excption);
},threadPool);
System.out.println("执行结果为："+future.get());

执行结果：

当前线程号：20
运行结果：5
异步任务成功执行....结果是：5,异常是：null
执行结果为：5

handle()

获取前一个异步线程的结果和异常，根据是否有异常产生执行不一样的逻辑

具体使用：

final CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("当前线程号：" + Thread.currentThread().getId());
    //int i = 10 / 0;
    int i = 10 / 2;
    System.out.println("运行结果：" + i);
    return i;
}, threadPool).handle((res,excption) -> {
    //异步方法执行完的后续处理
    if (excption != null){
        System.out.println("执行发生异常，返回默认数据，异常信息为：" + excption);
        return 10;
    }
    System.out.println("异步任务成功执行....上一步的结果是："+res);
    return res*2;
});
System.out.println("执行结果为："+future.get());

执行结果：

发生异常(int i = 10 / 0)时
	当前线程号：20
	执行发生异常，返回默认数据，异常信息为：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
	执行结果为：10

成功执行(int i = 10 / 2)时
	当前线程号：20
	运行结果：5
	异步任务成功执行....上一步的结果是：5
	执行结果为：10

3、线程穿行

方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行)。

//不能获取上一步的执行结果，也没有自己的返回值
ConnectionFuture<Void> thenRun(Runnable var1);
ConnectionFuture<Void> thenRunAsync(Runnable var1);
ConnectionFuture<Void> thenRunAsync(Runnable var1, Executor var2);

//能获取上一步的结果，但是没有自己返回值
ConnectionFuture<Void> thenAccept(Consumer<? super T> var1);
ConnectionFuture<Void> thenAcceptAsync(Consumer<? super T> var1);
ConnectionFuture<Void> thenAcceptAsync(Consumer<? super T> var1, Executor var2);

//能获取上一步的结果，而且有自己的返回值
<U> ConnectionFuture<U> thenApply(Function<? super T, ? extends U> var1);
<U> ConnectionFuture<U> thenApplyAsync(Function<? super T, ? extends U> var1);
<U> ConnectionFuture<U> thenApplyAsync(Function<? super T, ? extends U> var1, Executor var2);

//能获取上一步的结果，而且有自己的返回值
<U> ConnectionFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> var1);
<U> ConnectionFuture<U> thenCompose(BiFunction<? super T, ? super Throwable, ? extends CompletionStage<U>> var1);
<U> ConnectionFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> var1);
<U> ConnectionFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> var1, Executor var2);

thenRun()

不能获取上一步的执行结果，也没有自己的返回值

具体使用：

final CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("任务结束，运行结果：" + i);
    return i;
}, threadPool).thenRunAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
},threadPool);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
任务结束，运行结果：5
第二个任务，当前线程号：21
执行结果为：null

thenAccept()

能获取上一步的结果，但是没有自己返回值

具体使用：

final CompletableFuture<Void> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("任务结束，运行结果：" + i);
    return i;
}, threadPool).thenAcceptAsync(res -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("上个任务的结果："+res);
},threadPool);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
任务结束，运行结果：5
第二个任务，当前线程号：21
上个任务的结果：5
执行结果为：null

thenApply()

能获取上一步的结果，而且有自己的返回值，并且自己的返回值类型可以与上一个返回值的类型不一致

具体使用：

final CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("任务结束，运行结果：" + i);
    return i;
}, threadPool).thenApplyAsync(res -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("上个任务的结果："+res);
    return res*2+"个";
},threadPool);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
任务结束，运行结果：5
第二个任务，当前线程号：21
上个任务的结果：5
执行结果为：10个

thenCompose()

能获取上一步的结果，而且有自己的返回值，与thenApply()具有相同的功能

具体使用：

final CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("任务结束，运行结果：" + i);
    return i;
}, threadPool).thenComposeAsync(res -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("上个任务的结果：" + res);
    return CompletableFuture.supplyAsync(() -> {
        return res * 2 + "个";
    });
}, threadPool);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
任务结束，运行结果：5
第二个任务，当前线程号：21
上个任务的结果：5
执行结果为：10个

与thenApply()的区别：

thenApply()：返回的不是CompletableFuture类型
	它的功能相当于将CompletableFuture<T>转换成CompletableFuture<U>
thenCompose()：用来连接两个CompletableFuture，返回值是新的CompletableFuture

4、两个任务组合-都要完成

有点类似于 AND。方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行)。

//当两个任务都正常完成时，执行给定的操作
ConnectionFuture<Void> runAfterBoth(CompletionStage<?> var1, Runnable var2);
ConnectionFuture<Void> runAfterBothAsync(CompletionStage<?> var1, Runnable var2);
ConnectionFuture<Void> runAfterBothAsync(CompletionStage<?> var1, Runnable var2, Executor var3);

//当两个任务都正常完成时，使用两个结果作为参数，执行给定的操作，没有返回值
<U> ConnectionFuture<Void> thenAcceptBoth(CompletionStage<? extends U> var1, BiConsumer<? super T, ? super U> var2);
<U> ConnectionFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> var1, BiConsumer<? super T, ? super U> var2);
<U> ConnectionFuture<Void> thenAcceptBothAsync(CompletionStage<? extends U> var1, BiConsumer<? super T, ? super U> var2, Executor var3);

//当两个任务都正常完成时，使用两个结果作为参数，执行给定的操作，有返回值
<U, V> ConnectionFuture<V> thenCombine(CompletionStage<? extends U> var1, BiFunction<? super T, ? super U, ? extends V> var2);
<U, V> ConnectionFuture<V> thenCombineAsync(CompletionStage<? extends U> var1, BiFunction<? super T, ? super U, ? extends V> var2);
<U, V> ConnectionFuture<V> thenCombineAsync(CompletionStage<? extends U> var1, BiFunction<? super T, ? super U, ? extends V> var2, Executor var3);

runAfterBoth()

两个任务都执行完成后，执行下一步操作(Runnable类型任务)，没有使用前面两个任务的结果，也没有返回值

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("第一个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 5;
    System.out.println("第二个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<Void> future = future1.runAfterBoth(future2, () -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，没有参数，没有返回值");
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第一个任务，任务结束，运行结果：5
第二个任务，当前线程号：21
第二个任务，任务结束，运行结果：2
组合任务，当前线程号：1
执行指定操作，没有参数，没有返回值
执行结果为：null

thenAcceptBoth()

两个任务执行完成后，将结果交给thenAcceptBoth处理，可以使用前面两个任务的结果，但无自己的返回值

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("第一个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 5;
    System.out.println("第二个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<Void> future = future1.thenAcceptBoth(future2, (res1,res2) -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，前面任务的结果为："+res1+","+res2+"。没有自己的返回值");
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第一个任务，任务结束，运行结果：5
第二个任务，当前线程号：21
第二个任务，任务结束，运行结果：2
组合任务，当前线程号：1
执行指定操作，前面任务的结果为：5,2。没有自己的返回值
执行结果为：null

thenCombine()

两个任务执行完成后，将结果交给thenCombine处理，可以使用前面两个任务的结果，也有自己的返回值

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 2;
    System.out.println("第一个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int i = 10 / 5;
    System.out.println("第二个任务，任务结束，运行结果：" + i);
    return i;
}, threadPool);
final CompletableFuture<String> future = future1.thenCombineAsync(future2, (res1, res2) -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，前面任务的结果为："+res1+","+res2+"。有自己的返回值");
    return res1 + res2 + "个";
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第一个任务，任务结束，运行结果：5
第二个任务，当前线程号：21
第二个任务，任务结束，运行结果：2
组合任务，当前线程号：22
执行指定操作，前面任务的结果为：5,2。有自己的返回值
执行结果为：7个

5、两个任务组合-一个完成即可

有点类似于OR。方法不以Async结尾，意味着Action使用相同的线程执行，而Async可能会使用其它的线程去执行(如果使用相同的线程池，也可能会被同一个线程选中执行)。

//两个异步任务相比较，有任何一个执行完成，就进行下一步操作，不关心运行结果。
ConnectionFuture<Void> runAfterEither(CompletionStage<?> var1, Runnable var2);
ConnectionFuture<Void> runAfterEitherAsync(CompletionStage<?> var1, Runnable var2);
ConnectionFuture<Void> runAfterEitherAsync(CompletionStage<?> var1, Runnable var2, Executor var3);

//两个异步任务相比较，先获得执行结果的，就对该结果进行下一步的消费操作。
ConnectionFuture<Void> acceptEither(CompletionStage<? extends T> var1, Consumer<? super T> var2);
ConnectionFuture<Void> acceptEitherAsync(CompletionStage<? extends T> var1, Consumer<? super T> var2);
ConnectionFuture<Void> acceptEitherAsync(CompletionStage<? extends T> var1, Consumer<? super T> var2, Executor var3);

//两个异步任务相比较，先获得执行结果的，就对该结果进行下一步的转化操作。
<U> ConnectionFuture<U> applyToEither(CompletionStage<? extends T> var1, Function<? super T, U> var2);
<U> ConnectionFuture<U> applyToEitherAsync(CompletionStage<? extends T> var1, Function<? super T, U> var2);
<U> ConnectionFuture<U> applyToEitherAsync(CompletionStage<? extends T> var1, Function<? super T, U> var2, Executor var3);

runAfterEither()

两个异步任务相比较，有任何一个执行完成，就进行下一步操作，不关心运行结果。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Void> future = future1.runAfterEither(future2, () -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，没有参数，没有自己的返回值");
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第二个任务，任务结束，运行结果：1
组合任务，当前线程号：21
执行指定操作，没有参数，没有自己的返回值
执行结果为：null
第一个任务，任务结束，运行结果：2

acceptEither()

两个异步任务相比较，先获得执行结果的，就对该结果进行下一步的消费操作(即没有自己的返回值)。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Void> future = future1.acceptEither(future2, res -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，前面执行快的任务结果为："+res+"，没有自己的返回值");
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第一个任务，任务结束，运行结果：0
组合任务，当前线程号：1
执行指定操作，前面执行快的任务结果为：0，没有自己的返回值
执行结果为：null
第二个任务，任务结束，运行结果：1

applyToEither()

两个异步任务相比较，先获得执行结果的，就对该结果进行下一步的转化操作(即有自己的返回值)。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<String> future = future1.applyToEither(future2, res -> {
    System.out.println("组合任务，当前线程号：" + Thread.currentThread().getId());
    System.out.println("执行指定操作，前面执行快的任务结果为："+res+"，有自己的返回值");
    return res + "秒";
});
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第一个任务，任务结束，运行结果：2
组合任务，当前线程号：20
执行指定操作，前面执行快的任务结果为：2，有自己的返回值
执行结果为：2秒
第二个任务，任务结束，运行结果：9

6、多任务组合

以下方法都为静态方法

anyOf()

在给定多个异步任务第一个完成时，就马上返回一个新的 CompletableFuture。结果与其第一个完成的异步任务相同。即第一个异常完成则最终结果为异常完成，第一个正常完成则最终结果为正常完成。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第三个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第三个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Object> future = CompletableFuture.anyOf(future1, future2, future3);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第三个任务，当前线程号：22
第一个任务，任务结束，运行结果：1
执行结果为：1
第二个任务，任务结束，运行结果：2
第三个任务，任务结束，运行结果：7

allOf()

1、当给定的多个异步任务都正常完成后，返回一个新的 CompletableFuture，给定 CompletableFuture 的结果不会反映在返回的 CompletableFuture 中，但可以通过单独检查给定任务来获得结果。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 5;
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第三个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 2;
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第三个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
System.out.println("执行结果为："+future.get());
System.out.println("future1:"+future1.get());
System.out.println("future2:"+future2.get());
System.out.println("future3:"+future3.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第三个任务，当前线程号：22
第三个任务，任务结束，运行结果：2
第二个任务，任务结束，运行结果：5
第一个任务，任务结束，运行结果：7
执行结果为：null
future1:7
future2:5
future3:2

2、当任何一个异步任务异常完成，则返回的CompletableFuture 也会异常完成，并且将该异步任务的异常作为其原因。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 5;
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第三个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 2;
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第三个任务，任务结束，运行结果：" + number);
    throw new ArithmeticException();
}, threadPool);
final CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第三个任务，当前线程号：22
第一个任务，任务结束，运行结果：2
第三个任务，任务结束，运行结果：2
第二个任务，任务结束，运行结果：5
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.ArithmeticException
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1908)
	at com.itcxc.common.test.ThreadTest.main(ThreadTest.java:116)
Caused by: java.lang.ArithmeticException
	at com.itcxc.common.test.ThreadTest.lambda$main$2(ThreadTest.java:113)
	at java.util.concurrent.CompletableFuture$AsyncSupply.run(CompletableFuture.java:1604)
	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
	at java.lang.Thread.run(Thread.java:748)

3、当存在多个异常完成时，则返回排在前面的异步任务的异常信息。

具体使用：

final CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第一个任务，当前线程号：" + Thread.currentThread().getId());
    int number = new Random().nextInt(10);
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第一个任务，任务结束，运行结果：" + number);
    return number;
}, threadPool);
final CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第二个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 5;
    try {
        TimeUnit.SECONDS.sleep(5);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第二个任务，任务结束，运行结果：" + number);
    throw new NullPointerException();
}, threadPool);
final CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
    System.out.println("第三个任务，当前线程号：" + Thread.currentThread().getId());
    int number = 2;
    try {
        TimeUnit.SECONDS.sleep(number);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("第三个任务，任务结束，运行结果：" + number);
    throw new ArithmeticException();
}, threadPool);
final CompletableFuture<Void> future = CompletableFuture.allOf(future1, future2, future3);
System.out.println("执行结果为："+future.get());

执行结果：

第一个任务，当前线程号：20
第二个任务，当前线程号：21
第三个任务，当前线程号：22
第三个任务，任务结束，运行结果：2
第一个任务，任务结束，运行结果：2
第二个任务，任务结束，运行结果：5
Exception in thread "main" java.util.concurrent.ExecutionException: java.lang.NullPointerException
	at java.util.concurrent.CompletableFuture.reportGet(CompletableFuture.java:357)
	at java.util.concurrent.CompletableFuture.get(CompletableFuture.java:1908)
	at com.itcxc.common.test.ThreadTest.main(ThreadTest.java:116)
Caused by: java.lang.NullPointerException
	at com.itcxc.common.test.ThreadTest.lambda$main$1(ThreadTest.java:102)
头未秃
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture 详解
Siebelkang_j的博客
11-25 1995
默认情况下CompletableFuture会使用公共的ForkJoinPool线程池，这个线程池默认创建的线程数是 CPU 的核数（也可以通过 JVM option:-Djava.util.concurrent.ForkJoinPool.common.parallelism 来设置ForkJoinPool线程池的线程数）。使用没有指定Executor的方法时，内部使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。
CompletableFuture详解
全栈行动派的博客
04-07 5059
在使用Future时，会有线程堵塞、消耗CPU资源、多个任务不能顺序执行等局限，在jdk8中推出了加强版本的Future叫CompletableFuture解决了这些使用局限，本篇文章详细解释CompletableFuture的设计理念和使用
CompletableFuture详细讲解
最新发布
YYVeryGood的博客
05-29 2090
是Java提供的一个实现Future接口的类，它不仅支持传统的Future接口方法，还引入了许多新的方法来支持回调、组合、处理异常等功能。通过这些方法，开发者可以更方便地编写异步代码。默认情况下，使用作为其默认的线程池。你可以自定义执行器来控制任务的执行方式：​​。
CompletableFuture使用详解（全网看这一篇就行）
热门推荐
搬砖老农工的博客
04-02 7万+
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法 // 带返回值异步请求，默认线程池 public static <U> Completa
一文搞懂CompletableFuture的使用
weixin_45987961的博客
01-24 4264
前言 创建线程的方式只有两种：继承Thread或者实现Runnable接口。 但是这两种方法都存在一个缺陷，没有返回值 Java 1.5 以后，可以通过向线程池提交一个Callable来获取一个包含返回值的Future对象 Future接口的局限性 当Future的线程进行了一个非常耗时的操作，那我们的主线程也就阻塞了。 当我们在简单业务上，可以使用Future的另一个重载方法get(long,TimeUnit)来设置超时时间，避免我们的主线程被无穷尽地阻塞。 单纯使用Future接口或者Fut
Java8 CompletableFuture详解
09-04
主要介绍了Java8 CompletableFuture详解,CompletableFuture extends Future提供了方法，一元操作符和促进异步性以及事件驱动编程模型,需要的朋友可以参考下
图解CompletableFuture不创建线程的使用场景方法详解.docx
07-04
假设你使用 Future 运行子线程调用远程 API 来获取某款产品的最新价格，服务器由于洪灾宕机了，此时如果你想手动结束计算，而是想返回上次缓存中的价格，这是 Future 做不到的 调用 get() 方法会阻塞程序 Future ...
java异步编程详解
08-26
java异步编程详解 Java异步编程是Java编程语言中的一种编程模型，它允许程序异步地执行任务，以提高程序的性能和响应速度。在Java中，异步编程可以通过多种方式实现，包括使用Future、Callable、Runnable、Thread、...
@scheduled任务调度使用详解及@scheduled与多线程和@Async异步任务结合使用
12-13
return CompletableFuture.supplyAsync(() -> { // 异步执行的任务 try { Thread.sleep(3000); // 模拟耗时操作 } catch (InterruptedException e) { e.printStackTrace(); } return "当前时间：" + new ...
详解springboot中使用异步的常用两种方式及其比较
08-25
使用 CompletableFuture 的方式更加灵活，可以实现更加复杂的异步处理逻辑，但是需要手动处理异步任务的执行和结果。 在选择使用哪种方式时，需要考虑到具体的业务场景和需求。如果需要简单易用的异步处理，可以...
java-future-helper:一组实用程序，使使用Java 8的CompletableFuture，Stream和Timer类更加容易
04-11
未来助手FutureHelper是一个实用程序库，其中包含处理Java 8的CompletableFuture并将其与Vert.x AsyncResult类型处理程序和Java 8的流集成的有用方法。 FutureHelper的附加功能是使用Java 8的Timer类简化的计时器...
Spring Boot对Future模式的支持详解
08-26
主要给大家介绍了关于Spring Boot对Future模式的支持的相关资料，文中通过示例代码介绍的非常详细，对大家学习或者使用spring boot具有一定的参考学习价值，需要的朋友们下面来一起看看吧
HttpURLConnection用法详解
07-27
虽然HttpURLConnection本身不支持异步操作，但可以通过线程或Java 8的CompletableFuture等技术实现异步HTTP请求。 ### 11. 安全性 使用HTTPS时，HttpURLConnection会自动处理SSL/TLS加密，但也可以自定义SSLContext...
CompletableFuture使用详解（超详细）
javaeEEse的博客
02-20 7084
CompletableFuture就是帮你处理这些任务之间的逻辑关系，编排好任务的执行方式后，任务会按照规划好的方式一步一步执行，不需要让业务线程去频繁的等待。 比如说任务A，任务B，还有任务C。其中任务B还有任务C执行的前提是任务A先完成，再执行任务B和任务C。
CompletableFuture的使用
Evan's Blog ٩(๑❛ᴗ❛๑)۶
03-20 8712
现在大部分的CPU都是多核，我们都知道想要提升我们应用程序的运行效率，就必须得充分利用多核CPU的计算能力；Java为我们提供了大量多线程API，使用它们可以让我们的代码避免同步阻塞，从而达到提升运行效率的目的，CompletableFuture就是其中一个非常强大且重要API，下面我们就来介绍一下CompletableFuture的概念和使用。
completablefuture使用
07-28
CompletableFuture 是 Java 8 中新增的一种异步编程工具。 示例: ```java CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> { try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } return "Hello"; }).thenApply(s -> s + " World"); System.out.println(future.get()); // 输出 "Hello World" ``` 这个示例中，supplyAsync 方法用于异步执行一个任务，并返回一个 CompletableFuture 对象。thenApply 方法用于对上一步的结果进行处理，并返回一个新的 CompletableFuture。get 方法用于获取最终的结果。 另一个例子： ```java CompletableFuture<String> future1 = CompletableFuture.supplyAsync(() -> "Hello"); CompletableFuture<String> future2 = CompletableFuture.supplyAsync(() -> " World"); CompletableFuture<String> combinedFuture = future1.thenCombine(future2, (s1, s2) -> s1 + s2); System.out.println(combinedFuture.get()); // 输出 "Hello World" ``` 这个例子中，使用 thenCombine 方法将两个 CompletableFuture 对象组合起来，并返回一个新的 CompletableFuture 对象。 还有其他的方法可以实现类似的操作,如: thenAccept,thenRun,exceptionally等等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值