多线程之CompletableFuture（下）

最新推荐文章于 2023-07-21 15:59:03 发布
最新推荐文章于 2023-07-21 15:59:03 发布
阅读量455 收藏 2
点赞数
分类专栏： 多线程 文章标签： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Kincym/article/details/78469292
版权

thenAcceptBothAsync

thenAcceptBothAsync(CompletionStage<? extends U> other,
        BiConsumer<? super T, ? super U> action)

同时执行两个线程，获取两个返回结果T,U作为参数，进入BiConsumer<T, U>，retrun Void,返回 CompletableFuture<Void>

public static void main(String[] args) {
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello";
        }).thenAcceptBothAsync(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---");
            return "hello".length();
        }), (t, v) -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "........." + t + "---" + v);
        });
        System.out.println("---------------------------");
        voidCompletableFuture.join();
    }

这里写图片描述

acceptEitherAsync

acceptEitherAsync(
        CompletionStage<? extends T> other, Consumer<? super T> action)

获取快的线程的结果(两个线程返回类型需一致)T，T作为参数，进入Consumer，return void,返回CompletableFuture<Void>

public static void main(String[] args) {
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello1";
        }).acceptEitherAsync(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---");
            return "hello2";
        }), t -> {
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "........." + t);
        });

        System.out.println("---------------------------");
        voidCompletableFuture.join();
    }

这里写图片描述

runAfterBothAsync

runAfterBothAsync(CompletionStage<?> other, Runnable action)

两个线程执行完毕后,不关心结果,进入Runnable ，return void,返回CompletableFuture<Void>

public static void main(String[] args) {
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello1";
        }).runAfterBothAsync(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---");
            return "hello2".length();
        }), () -> {
            System.out.println(Thread.currentThread().getName() + ".........");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ".........");
        });

        System.out.println("---------------------------");
        voidCompletableFuture.join();
    }

这里写图片描述

runAfterEitherAsync

CompletableFuture<Void> runAfterEitherAsync(CompletionStage<?> other,
                                                       Runnable action)

有线程结束后,不关心结果,进入Runnable ，return void,返回CompletableFuture<Void>

public static void main(String[] args) {
        CompletableFuture<Void> voidCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            try {
                TimeUnit.SECONDS.sleep(5);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello1";
        }).runAfterEitherAsync(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---");
            return "hello2".length();
        }), () -> {
            System.out.println(Thread.currentThread().getName() + ".........");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + ".........");
        });

        System.out.println("---------------------------");
        voidCompletableFuture.join();
    }

这里写图片描述

thenCombineAsync

CompletableFuture<V> thenCombineAsync(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V>

同时执行两个线程，获取两个返回结果T,U作为参数，进入BiFunction,return v , CompletableFuture<V>

public static void main(String[] args) {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello1";
        }).thenCombineAsync(CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---");
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---");
            return 100;
        }), (t, u) -> {
            System.out.println(Thread.currentThread().getName() + "........." + t);
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "........." + u);
            return "=thenCombine=";
        });

        try {
            System.out.println("---------------------------" + completableFuture.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这里写图片描述

thenComposeAsync

CompletableFuture<U> thenComposeAsync(
        Function<? super T, ? extends CompletionStage<U>> fn)
public static void main(String[] args) {
        CompletableFuture<Integer> completableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------开始---");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync1---------结束---");
            return "hello1";
        }).thenComposeAsync(t -> {
            CompletableFuture<Integer> integerCompletableFuture = CompletableFuture.supplyAsync(() -> {
                System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------开始---" + t);
                try {
                    TimeUnit.SECONDS.sleep(3);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "---------supplyAsync2---------结束---" + t);
                return 100;
            });
            return integerCompletableFuture;
        });

        try {
            System.out.println("=----------------------------=");
            System.out.println("---------------------------" + completableFuture.get());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这里写图片描述

其它方法

  • getNow(T valueIfAbsent)：线程执行完了，获取返回的值，如果没有执行完毕，返回指定值。不阻塞。
public static void main(String[] args) {
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync----begin-------"+ System.currentTimeMillis());
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync-----end------"+ System.currentTimeMillis());
            return "hello";
        });
        //执行完了 获取返回的值，如果没有执行完毕，返回指定值
        String now = stringCompletableFuture.getNow("i am getNow value");
        System.err.println(Thread.currentThread().getName() + "=====getNow值：" + now + " ====时间： " + System.currentTimeMillis());
        try {
            System.err.println(Thread.currentThread().getName() + "====get值：" + stringCompletableFuture.get() + "===时间： " + System.currentTimeMillis());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这里写图片描述

  • complete(T value)：若完成，返回false,get()时获取返回值; 若未完成，返回true,get()时获取指定值。
public static void main(String[] args) {
        CompletableFuture<String> stringCompletableFuture = CompletableFuture.supplyAsync(() -> {
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync----begin-------"+ System.currentTimeMillis());
            try {
                TimeUnit.SECONDS.sleep(4);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "---------supplyAsync-----end------"+ System.currentTimeMillis());
            return "hello";
        });
        try {
            TimeUnit.SECONDS.sleep(5);
        } catch (Exception e) {
            e.printStackTrace();
        }
        //若完成，返回false,get()时获取返回值; 若未完成，返回true,get()时获取指定值
        boolean complete = stringCompletableFuture.complete("WWWWW");
        System.out.println(complete);
        try {
            System.out.println(Thread.currentThread().getName() + "  get值：" + stringCompletableFuture.get() + " 时间： " + System.currentTimeMillis());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

这里写图片描述

  • completeExceptionally(Throwable ex)：//若完成，返回false,get()时获取返回值; 若未完成，返回true,get()时抛出指定异常
Kincym
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程--CompletableFuture
qq_40597962的博客
05-10 593
多线程的学习笔记（2） 大家在工作的时候，肯定会遇到很多多线程的场景。我们先简单的比较一下单线程和多线程之间的差距 public static void main(String[] args) throws ExecutionException, InterruptedException { //单线程计算累加 Instant start = Instant.now(); long num=0; for (long i = 0; i &lt
多线程----Future
不忘初心 ，方得始终
08-31 3271
Guava为Java并行编程Future提供了很多有用扩展，其主要接口为ListenableFuture，并借助于Futures静态扩展。 继承至Future的ListenableFuture，允许我们添加回调函数在线程运算完成时返回值或者方法执行完成立即返回。 对ListenableFuture添加回调函数： Futures.addCallback(ListenableFuture
java多线程
小趴菜不能喝的博客
09-22 276
java 线程创建、线程状态、线程同步、线程协作问题
CompletableFuture 使用详解
江城宴的博客
12-22 7202
CompletableFuture 使用详解 1、 runAsync 和 supplyAsync方法 CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture&...
java线程池异步使用
thebinso的博客
05-23 4490
1.原生的线程池对象（本人推荐使用这个） package d7_threadpool; import java.util.concurrent.*; /* * public ThreadPoolExecutor(int corePoolSize, * int maximumPoolSize, * long keepAliveTime, * TimeUnit unit, * BlockingQueue<Runnable> workQueue, * ThreadFactory thre
JAVA8-Future和CompletableFuture
从码农到码到成功
01-17 845
如果还想处理结果（没有异常的情况），那就用handle，比whenComplete友好一些，handle不仅能处理异常还能返回一个异常情况的默认值。Future：我们的目的都是获取异步任务的结果，但是对于Future来说，只能通过get方法或者死循环判断isDone来获取。异常情况就更是难办。thenCombine：至少两个方法参数，一个为其它stage，一个为用户自定义的处理函数，函数返回值为结果类型。3. 如果有复杂任务，比如依赖问题，组合问题等，同样可以写好处理函数来处理（能应付复杂任务的处理）
Java CompletableFuture : thenAcceptBothAsync
Zhang Phil
06-19 1990
CompletableFuture&lt;String&gt; future1 = CompletableFuture.supplyAsync(new Supplier&lt;String&gt;() { @Override public String get() { return "zhangphil...
多线程异步编程之CompletableFuture入门-release
最新发布
02-02
强化学习.您将收获: - 为什么会选择 CompletableFuture - 如何创建CompletableFuture异步任务 - CompletableFuture异步任务回调使用 - CompletableFuture异步任务编排 - CompletableFuture的异常处理
多线程文章目录
01-21
以下文章基本上保证真实可信，如...Java多线程②——多线程知识梳理 有助于了解线程池相关的知识、包括线程池执行逻辑、常用方法； 以及java为我们提供常用的线程池和任务调度ScheduledExecutorService以及工作窃取For
Java多线程守护线程
12-22
　User和Daemon两者几乎没有区别，的不同之处在于虚拟机的离开：如果 User Thread已经全部退出运行了，只剩下Daemon Thread存在了，虚拟机也退出了。 因为没有了被守护者，Daemon也没有工作可做了，也没有继续运行...
多线程（二）
12-22
在Java编程中，多线程是并发处理任务的关键机制，特别是在高性能、高并发的应用场景下。然而，直接创建和管理大量的线程会带来资源浪费和性能瓶颈，这就是线程池的作用所在。线程池通过预先配置好的一组线程来处理...
JUC多线程学习个人笔记
07-08
Java Util Concurrent（JUC）是Java并发编程的核心库，提供了丰富的工具和接口，使得...总的来说，JUC库为Java开发者提供了强大的工具，有效地解决了并发编程中的诸多挑战，提升了多线程环境下的程序效率和稳定性。
CompletableFuture实现多线程异步任务编排
sinat_31583645的博客
02-24 1252
在Java 8中, 新增加了一个包含50个方法左右的类: CompletableFuture，提供了非常强大的Future扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。CompletableFuture类实现了Future接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。CompletableFuture和FutureTask同属于Future接口。
异步编排CompletableFuture
xiang_yu_pai的博客
07-25 268
异步编排使用CompletableFuture执行方法runAsync()返回空值 supplyAsync()返回结果handle() 感知异常并且能返回结果thenRunAsync()方法 不接受上一步结果执行，不返回结果thenAcceptAsync()方法 接受上一步结果，但不返回结果thenApplyAsync()方法 接受上一步结果，返回结果runAfterBothAsync()不接受结果，不返回结果thenAcceptBothAsync()接受结果，不返回结果thenCombine
线程池&异步编排
dgdxfgfdfdb的博客
06-07 370
线程池和异步编排的使用方式
Java8异步任务CompletableFuture使用
qq_38730338的博客
04-06 1529
从上面可以看出cf1任务完成需要2秒，cf2任务完成需要5秒，使用applyToEither组合两个任务时，只要有其中一个任务完成时，就会执行cf3任务，显然cf1任务先完成了并且将自己任务的结果传值给了cf3任务，cf3任务中打印了接收到cf1任务完成，接着完成自己的任务，并返回cf3任务完成；anyOf ：CompletableFuture是多个任务只要有一个任务执行完成，则返回的CompletableFuture执行get方法时会抛出异常，如果都是正常执行，则get返回执行完成任务的结果。
那些年我们追过的异步骚操作：ListenableFuture、CompletableFuture、RxJava(Observable)
布道
03-13 5911
Futures在Java 5(2004)中引入。它们是承诺在操作完成后保留操作结果的对象。调用者可以使用future对象来检查操作isDone()，或者等待它完成使用get()。Future模式一个最大的问题是何时调用问题（过早地阻塞Future.get()，这消除了异步执行的好处）。guava的 ListenableFuture、java8的CompletableFuture、RxJava的...
CompletableFuture
yearraey的博客
07-21 119
thenCompose thenComposeAsync：某个任务执行完成后执行的动作，Function<?whenComplete whenCompleteAsync：某个任务执行完成后执行的动作，BiConsumer<?thenApply thenApplyAsync：某个任务执行完成后执行的动作，Function<?runAfterBoth runAfterBothAsync：两个任务都执行完成后，执行下一步操作，没有入参，也没有返回值。以Async结尾的方法，都是异步的，否则是同步的。
多线程之invokeAny,invokeAll介绍
Kincym的博客
10-25 6839
方法invokeAny,invokeAll具有阻塞性。 invokeAny取得第一个方法的返回值,当第一个任务结束后，会调用interrupt方法中断其它任务。 invokeAll等线程任务执行完毕后,取得全部任务的结果值。 invokeAnyinvokeAny(Collection<? extends Callable<T>> tasks)：public class InvokeAnyTest {
java 多线程使用CompletableFuture和execute的区别
05-14
Java中的多线程有多种实现方式，其中包括使用CompletableFuture和使用Executor。 CompletableFuture是Java 8中新增的类，用于支持异步编程和函数式编程。它提供了一种简单的方式来处理异步任务的结果。使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值