CompletableFuture教程

最新推荐文章于 2024-05-29 22:55:19 发布
最新推荐文章于 2024-05-29 22:55:19 发布
阅读量245 收藏 1
点赞数
分类专栏： 高并发 异步 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42351206/article/details/124566092
版权

文章目录

前言

java程序员绕不开的就是高并发。而高并发系列中，无非就是异步、锁、多线程。今天要介绍的就是CompletableFuture。本人水平有限，如有误导，欢迎斧正，一起学习，共同进步！

一、基础篇

1、案例1_ CompletableFuture.supplyAsync()

1.1、需求

有三步骤，(名字相同的是同一个线程。小白是一个线程，厨师是一个线程)：
1、小白点菜
2、厨师做菜
3、小白吃饭

1.2、代码

package com.zheng.sync;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/04/26 21:59
 * @desc: CompletableFuture 基础篇_1
 *      1、小白点菜
 *      2、厨师做菜
 *      3、小白吃饭
 *
 *
 */
public class CompletableFutureBasicOne {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白进入餐厅");
        SmallUtil.printTimeAndThread("小白点了 番茄炒蛋 + 米饭");
        SmallUtil.printTimeAndThread("小白再打王者1");

        // jdk8的异步
        CompletableFuture<String > cf1 = CompletableFuture.supplyAsync(()->{
            SmallUtil.printTimeAndThread("厨师开始炒菜了");
            SmallUtil.sleepMillis(1000L);
            SmallUtil.printTimeAndThread("厨师开始打饭了");
            SmallUtil.sleepMillis(1000L);
            return "番茄炒蛋 + 米饭 做好了";
        });

        SmallUtil.printTimeAndThread("小白再打王者2");
        /**
         * cf1.join() 的结果集，就是 CompletableFuture的泛型的值，
         * cf1.join() 也会抛出异常
         */
        SmallUtil.printTimeAndThread(String.format("%s,小白开吃了",cf1.join()));

        /**
         * 结果：
         *  2022-04-26 10:04:26    |  1  |  main   |  小白进入餐厅
         * 2022-04-26 10:04:26 |  1  |  main   |  小白点了 番茄炒蛋 + 米饭
         * 2022-04-26 10:04:26 |  1  |  main   |  小白再打王者1
         * 2022-04-26 10:04:26 |  1  |  main   |  小白再打王者2
         * 2022-04-26 10:04:26 |  12 |  ForkJoinPool.commonPool-worker-9   |  厨师开始炒菜了
         * 2022-04-26 10:04:27 |  12 |  ForkJoinPool.commonPool-worker-9   |  厨师开始打饭了
         * 2022-04-26 10:04:28 |  1  |  main   |  番茄炒蛋 + 米饭 做好了,小白开吃了
         */
    }
}

1.3、总结

CompletableFuture.supplyAsync(() -> {return “”;})。supplyAsync 是支持返回值的异步；runAsync 不支持返回值的异步。

2、案例2_ CompletableFuture.thenCompose()

2.1、需求

1、小白点餐
2、厨师做饭
3、服务器送菜(这个需要在2的后面执行)
4、小白吃饭

2.2、代码

package com.zheng.sync;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/04/26 22:32
 * @desc: CompletableFuture 基础篇_2
 *      1、小白点餐
 *      2、厨师做饭
 *      3、服务器送菜(这个需要在2的后面执行)
 *      4、小白吃饭
 */
public class CompletableFutureBasicTwo {

    public static void main(String[] args) {

        SmallUtil.printTimeAndThread("小白进入餐厅");
        SmallUtil.printTimeAndThread("小白点了 番茄炒蛋 + 米饭");
        SmallUtil.printTimeAndThread("小白再打王者1");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("厨师开始炒菜了");
            SmallUtil.sleepMillis(1000L);
            return "番茄炒蛋";
        }).thenCompose(dist -> CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("服务员开始打饭了");
            SmallUtil.sleepMillis(1000L);
            return dist + "米饭";
        }));

        /**
         * thenCompose 这个方法中：是吧前面任务的结果，交给下一个任务
         *  1、dist 代表着前面那个线程的返回值，这里是 番茄炒蛋(String)
         *  2、 CompletableFuture.supplyAsync 代表着，里面的代码会在领一个线程中执行
         *  3、前一个任务完成，有结果以后，下一个任务才会触发
         */

        SmallUtil.printTimeAndThread("小白再打王者2");
        SmallUtil.printTimeAndThread(String.format("%s,小白开吃了",cf1.join()));


        /**
         * 2022-04-26 10:04:17 |  1  |  main   |  小白进入餐厅
         * 2022-04-26 10:04:17 |  1  |  main   |  小白点了 番茄炒蛋 + 米饭
         * 2022-04-26 10:04:17 |  1  |  main   |  小白再打王者1
         * 2022-04-26 10:04:17 |  12 |  ForkJoinPool.commonPool-worker-9   |  厨师开始炒菜了
         * 2022-04-26 10:04:17 |  1  |  main   |  小白再打王者2
         * 2022-04-26 10:04:19 |  12 |  ForkJoinPool.commonPool-worker-9   |  服务员开始打饭了
         * 2022-04-26 10:04:20 |  1  |  main   |  番茄炒蛋米饭,小白开吃了
         */
    }
}

2.3、总结

CompletableFuture.supplyAsync().thenCompose(); 这个thenCompose中的方法，是再第一个的后面执行的。

3、案例3_ CompletableFuture.thenCombine()

3.1、需求

1、小白点饭
2、厨师做饭
3、服务器蒸米饭 (2、3 是同事进行的，没有先后顺序)
4、小白吃饭

3.2、代码

package com.zheng.sync.basic;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/04/26 22:58
 * @desc: CompletableFuture 基础篇_2
 *      1、小白点饭
 *      2、厨师做饭
 *      3、服务器蒸米饭  (2、3 是同事进行的，没有先后顺序)
 *      4、小白吃饭
 */
public class CompletableFutureBasicThree {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白进入餐厅");
        SmallUtil.printTimeAndThread("小白点了 番茄炒蛋 + 米饭");
        SmallUtil.printTimeAndThread("小白再打王者1");

        CompletableFuture cf1 = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("厨师开始炒菜了");
            SmallUtil.sleepMillis(1000L);
            return "番茄炒蛋";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("服务员开始蒸米饭了");
            SmallUtil.sleepMillis(1000L);
            return "米饭";
        }), (dish,rice) -> {
            SmallUtil.printTimeAndThread("服务员开始打饭了");
            SmallUtil.sleepMillis(1000L);
            return String.format("%s + %s 好了啊" ,dish,rice);
        } );

        /**
         * thenCombine 代表着，这俩异步任务是同时执行的，同时执行完了以后，再把他们加工成一个结果
         */

        SmallUtil.printTimeAndThread("小白再打王者2");
        SmallUtil.printTimeAndThread(String.format("%s,小白开吃了",cf1.join()));

        /**
         * 2022-04-26 11:04:36 |  1  |  main   |  小白进入餐厅
         * 2022-04-26 11:04:36 |  1  |  main   |  小白点了 番茄炒蛋 + 米饭
         * 2022-04-26 11:04:36 |  1  |  main   |  小白再打王者1
         * 2022-04-26 11:04:36 |  12 |  ForkJoinPool.commonPool-worker-9   |  厨师开始炒菜了
         * 2022-04-26 11:04:36 |  13 |  ForkJoinPool.commonPool-worker-2   |  服务员开始蒸米饭了
         * 2022-04-26 11:04:36 |  1  |  main   |  小白再打王者2
         * 2022-04-26 11:04:37 |  13 |  ForkJoinPool.commonPool-worker-2   |  服务员开始打饭了
         * 2022-04-26 11:04:38 |  1  |  main   |  番茄炒蛋 + 米饭 好了啊,小白开吃了
         */
    }
}

3.3、总结

CompletableFuture.supplyAsync().thenCombine();这个thenCombine代表他们是同时执行的。

二、扩展篇

1、案例1_ CompletableFuture.thenApplyAsync()

1.1、需求

1、小白吃好了
2、小白结账 要发票
3、小白接到朋友电话，约定了一起打游戏
4、服务员收款
5、收银员开发票(注意，和上面的4，不是一个人)
6、小白收到发票，准备回家

1.2、代码

package com.zheng.sync.advance;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/04/27 22:50
 * @desc: 另一种实现方式
 *      1、小白吃好了
 *      2、小白结账 要发票
 *      3、小白接到朋友电话，约定了一起打游戏
 *      4、服务员收款
 *      5、收银员开发票(注意，和上面的4，不是一个人)
 *      6、小白收到发票，准备回家
 */
public class CompletableFutureAdvanceOne_2 {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白吃好了");
        SmallUtil.printTimeAndThread("小白结账 要发票");
//        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() ->{
//            SmallUtil.printTimeAndThread("服务员收款");
//            SmallUtil.sleepMillis(1000L);
//            return "服务员收款";
//        }).thenApplyAsync(dist ->  {
//            SmallUtil.printTimeAndThread("收银员开发票");
//            SmallUtil.sleepMillis(1000L);
//            return "收银员开发票";
//        } );

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("服务员收款 500元");
            SmallUtil.sleepMillis(1000L);
            return "500";
        }).thenApplyAsync(money -> {
            SmallUtil.printTimeAndThread(String.format("收银员开发票 %s" ,money));
            SmallUtil.sleepMillis(1000L);
            return String.format("收银员开发票 %s" ,money);
        });

        SmallUtil.printTimeAndThread("小白接到朋友电话，约定了一起打游戏");

        SmallUtil.printTimeAndThread(String.format("小白收到%s,准备回家",cf1.join()));

        /**
         * "C:\Program Files\Java\jdk1.8.0_161\bin\java.exe" -javaagent:D:\java\ruanjian\idea\path\lib\idea_rt.jar=53062:D:\java\ruanjian\idea\path\bin -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_161\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\rt.jar;D:\java\ruanjian\idea\file\testcompletablefuture\target\classes;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-web\2.6.7\spring-boot-starter-web-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter\2.6.7\spring-boot-starter-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot\2.6.7\spring-boot-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-autoconfigure\2.6.7\spring-boot-autoconfigure-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-logging\2.6.7\spring-boot-starter-logging-2.6.7.jar;D:\java\ruanjian\maven\cangku\ch\qos\logback\logback-classic\1.2.11\logback-classic-1.2.11.jar;D:\java\ruanjian\maven\cangku\ch\qos\logback\logback-core\1.2.11\logback-core-1.2.11.jar;D:\java\ruanjian\maven\cangku\org\apache\logging\log4j\log4j-to-slf4j\2.17.2\log4j-to-slf4j-2.17.2.jar;D:\java\ruanjian\maven\cangku\org\apache\logging\log4j\log4j-api\2.17.2\log4j-api-2.17.2.jar;D:\java\ruanjian\maven\cangku\org\slf4j\jul-to-slf4j\1.7.36\jul-to-slf4j-1.7.36.jar;D:\java\ruanjian\maven\cangku\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;D:\java\ruanjian\maven\cangku\org\yaml\snakeyaml\1.29\snakeyaml-1.29.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-json\2.6.7\spring-boot-starter-json-2.6.7.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-databind\2.13.2.1\jackson-databind-2.13.2.1.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-annotations\2.13.2\jackson-annotations-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-core\2.13.2\jackson-core-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.13.2\jackson-datatype-jdk8-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.13.2\jackson-datatype-jsr310-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\module\jackson-module-parameter-names\2.13.2\jackson-module-parameter-names-2.13.2.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-tomcat\2.6.7\spring-boot-starter-tomcat-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-core\9.0.62\tomcat-embed-core-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-el\9.0.62\tomcat-embed-el-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.62\tomcat-embed-websocket-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-web\5.3.19\spring-web-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-beans\5.3.19\spring-beans-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-webmvc\5.3.19\spring-webmvc-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-aop\5.3.19\spring-aop-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-context\5.3.19\spring-context-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-expression\5.3.19\spring-expression-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\projectlombok\lombok\1.18.24\lombok-1.18.24.jar;D:\java\ruanjian\maven\cangku\org\slf4j\slf4j-api\1.7.36\slf4j-api-1.7.36.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-core\5.3.19\spring-core-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-jcl\5.3.19\spring-jcl-5.3.19.jar" com.zheng.sync.advance.CompletableFutureAdvanceOne_2
         * 2022-05-04 10:05:16	|	1	|	main	|	小白吃好了
         * 2022-05-04 10:05:16	|	1	|	main	|	小白结账 要发票
         * 2022-05-04 10:05:16	|	12	|	ForkJoinPool.commonPool-worker-9	|	服务员收款 500元
         * 2022-05-04 10:05:16	|	1	|	main	|	小白接到朋友电话，约定了一起打游戏
         * 2022-05-04 10:05:17	|	12	|	ForkJoinPool.commonPool-worker-9	|	收银员开发票 500
         * 2022-05-04 10:05:18	|	1	|	main	|	小白收到收银员开发票 500,准备回家
         */
    }
}

1.3、总结

CompletableFuture.supplyAsync() .thenApplyAsync();这个thenApplyAsync虽然有先后顺序，但是是俩个线程。

2、案例2_ CompletableFuture.applyToEither()

2.1、需求

1、小白吃完了，准备回家
2、小白在等车，哪个车先来，就做哪个车

2.2、代码

package com.zheng.sync.advance;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/04/28 23:03
 * @desc: CompletableFuture扩展_2
 *      1、小白吃完了，准备回家
 *      2、小白在等车，哪个车先来，就做哪个车
 *
 *  todo: .applyToEither()  俩线程，谁先执行完，就把先执行完的结果返回给Future
 */
public class CompletableFutureAdvanceTwo {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白吃完了，准备回家");
        SmallUtil.printTimeAndThread("小白在等车");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("70路公交来了");
            SmallUtil.sleepMillis(3000L);
            return "70路公交";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("80路公交来了");
            SmallUtil.sleepMillis(2000L);
            return "80路公交";
        }),firstComeBus -> firstComeBus);

        /**
         * 2022-04-28 11:04:04 |  1  |  main   |  小白吃完了，准备回家
         * 2022-04-28 11:04:04 |  1  |  main   |  小白在等车
         * 2022-04-28 11:04:04 |  12 |  ForkJoinPool.commonPool-worker-9   |  70路公交来了
         * 2022-04-28 11:04:04 |  13 |  ForkJoinPool.commonPool-worker-2   |  80路公交来了
         * 2022-04-28 11:04:06 |  1  |  main   |  小白坐上了 80路公交
         */
        SmallUtil.printTimeAndThread(String.format("小白坐上了 %s ",cf1.join()));
    }
}

2.3、总结

CompletableFuture.supplyAsync().applyToEither(); 中的applyToEither 代表着谁先来，就先执行谁

3、案例3_ CompletableFuture.exceptionally()

3.1、需求

1、小白吃完了，准备回家
2、小白在等车，哪个车先来，就做哪个车
3、假设小白做的是700路公交，然后700路公交路上没电了，然后小白打车回家

3.2、代码

3.2.1、没处理异常的代码：
package com.zheng.sync.advance;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/05/04 9:45
 * @desc: 这个主要是处理，CompletableFutureAdvance 的异常处理
 *      1、小白吃完了，准备回家
 *      2、小白在等车，哪个车先来，就做哪个车
 *      3、假设小白做的是700路公交，然后700路公交路上没电了，然后小白打车回家
 */
public class CompletableFutureAdvanceThree {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白吃完了，准备回家");
        SmallUtil.printTimeAndThread("小白在等车");

        CompletableFuture<String> bus = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("700路公交来了");
            SmallUtil.sleepMillis(1000L);
            return "700路公交";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("800路公交来了");
            SmallUtil.sleepMillis(2000L);
            return "800路公交";
        }),firstComeBus -> {
            SmallUtil.printTimeAndThread("小白坐上了"+firstComeBus);
            if (firstComeBus.startsWith("700")){
                throw new RuntimeException("700路公交没电了");
            }
            return firstComeBus;
        });

        /**
         * 抛出一下异常：
         *  Exception in thread "main" java.util.concurrent.CompletionException: java.lang.RuntimeException: 700路公交没电了
         *  Caused by: java.lang.RuntimeException: 700路公交没电了
         *  at com.zheng.sync.advance.CompletableFutureAdvanceThree.lambda$main$2(CompletableFutureAdvanceThree.java:32)
         */

        SmallUtil.printTimeAndThread(String.format("%s,小白做车回家",bus.join()));
    }
}
3.2.2、处理了异常的代码：
package com.zheng.sync.advance;

import com.zheng.util.SmallUtil;

import java.util.concurrent.CompletableFuture;

/**
 * @author: ZhengTianLiang
 * @date: 2022/05/04 9:45
 * @desc: 这个主要是处理，CompletableFutureAdvance 的异常处理
 *      1、小白吃完了，准备回家
 *      2、小白在等车，哪个车先来，就做哪个车
 *      3、假设小白做的是700路公交，然后700路公交路上没电了，然后小白打车回家
 *  todo: 是为了处理，前面抛出的异常
 */
public class CompletableFutureAdvanceThree_2 {

    public static void main(String[] args) {
        SmallUtil.printTimeAndThread("小白吃完了，准备回家");
        SmallUtil.printTimeAndThread("小白在等车");

        CompletableFuture<String> bus = CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("700路公交来了");
            SmallUtil.sleepMillis(1000L);
            return "700路公交";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            SmallUtil.printTimeAndThread("800路公交来了");
            SmallUtil.sleepMillis(2000L);
            return "800路公交";
        }),firstComeBus -> {
            SmallUtil.printTimeAndThread("小白坐上了"+firstComeBus);
            if (firstComeBus.startsWith("700")){
                throw new RuntimeException("700路公交没电了");
            }
            return firstComeBus;
        }).exceptionally(e -> {
            SmallUtil.printTimeAndThread("进去了异常的方法"+e.getMessage());
            return "做了出租车";
        });

        /**
         * "C:\Program Files\Java\jdk1.8.0_161\bin\java.exe" -javaagent:D:\java\ruanjian\idea\path\lib\idea_rt.jar=50710:D:\java\ruanjian\idea\path\bin -Dfile.encoding=UTF-8 -classpath "C:\Program Files\Java\jdk1.8.0_161\jre\lib\charsets.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\deploy.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\access-bridge-64.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\cldrdata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\dnsns.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jaccess.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\jfxrt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\localedata.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\nashorn.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunec.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunjce_provider.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunmscapi.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\sunpkcs11.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\ext\zipfs.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\javaws.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jce.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfr.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jfxswt.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\jsse.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\management-agent.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\plugin.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\resources.jar;C:\Program Files\Java\jdk1.8.0_161\jre\lib\rt.jar;D:\java\ruanjian\idea\file\testcompletablefuture\target\classes;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-web\2.6.7\spring-boot-starter-web-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter\2.6.7\spring-boot-starter-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot\2.6.7\spring-boot-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-autoconfigure\2.6.7\spring-boot-autoconfigure-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-logging\2.6.7\spring-boot-starter-logging-2.6.7.jar;D:\java\ruanjian\maven\cangku\ch\qos\logback\logback-classic\1.2.11\logback-classic-1.2.11.jar;D:\java\ruanjian\maven\cangku\ch\qos\logback\logback-core\1.2.11\logback-core-1.2.11.jar;D:\java\ruanjian\maven\cangku\org\apache\logging\log4j\log4j-to-slf4j\2.17.2\log4j-to-slf4j-2.17.2.jar;D:\java\ruanjian\maven\cangku\org\apache\logging\log4j\log4j-api\2.17.2\log4j-api-2.17.2.jar;D:\java\ruanjian\maven\cangku\org\slf4j\jul-to-slf4j\1.7.36\jul-to-slf4j-1.7.36.jar;D:\java\ruanjian\maven\cangku\jakarta\annotation\jakarta.annotation-api\1.3.5\jakarta.annotation-api-1.3.5.jar;D:\java\ruanjian\maven\cangku\org\yaml\snakeyaml\1.29\snakeyaml-1.29.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-json\2.6.7\spring-boot-starter-json-2.6.7.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-databind\2.13.2.1\jackson-databind-2.13.2.1.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-annotations\2.13.2\jackson-annotations-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\core\jackson-core\2.13.2\jackson-core-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\datatype\jackson-datatype-jdk8\2.13.2\jackson-datatype-jdk8-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\datatype\jackson-datatype-jsr310\2.13.2\jackson-datatype-jsr310-2.13.2.jar;D:\java\ruanjian\maven\cangku\com\fasterxml\jackson\module\jackson-module-parameter-names\2.13.2\jackson-module-parameter-names-2.13.2.jar;D:\java\ruanjian\maven\cangku\org\springframework\boot\spring-boot-starter-tomcat\2.6.7\spring-boot-starter-tomcat-2.6.7.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-core\9.0.62\tomcat-embed-core-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-el\9.0.62\tomcat-embed-el-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\apache\tomcat\embed\tomcat-embed-websocket\9.0.62\tomcat-embed-websocket-9.0.62.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-web\5.3.19\spring-web-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-beans\5.3.19\spring-beans-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-webmvc\5.3.19\spring-webmvc-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-aop\5.3.19\spring-aop-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-context\5.3.19\spring-context-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-expression\5.3.19\spring-expression-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\projectlombok\lombok\1.18.24\lombok-1.18.24.jar;D:\java\ruanjian\maven\cangku\org\slf4j\slf4j-api\1.7.36\slf4j-api-1.7.36.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-core\5.3.19\spring-core-5.3.19.jar;D:\java\ruanjian\maven\cangku\org\springframework\spring-jcl\5.3.19\spring-jcl-5.3.19.jar" com.zheng.sync.advance.CompletableFutureAdvanceThree_2
         * 2022-05-04 09:05:36 |  1  |  main   |  小白吃完了，准备回家
         * 2022-05-04 09:05:36 |  1  |  main   |  小白在等车
         * 2022-05-04 09:05:36 |  12 |  ForkJoinPool.commonPool-worker-9   |  700路公交来了
         * 2022-05-04 09:05:36 |  13 |  ForkJoinPool.commonPool-worker-2   |  800路公交来了
         * 2022-05-04 09:05:37 |  12 |  ForkJoinPool.commonPool-worker-9   |  小白坐上了700路公交
         * 2022-05-04 09:05:37 |  12 |  ForkJoinPool.commonPool-worker-9   |  进去了异常的方法java.lang.RuntimeException: 700路公交没电了
         * 2022-05-04 09:05:37 |  1  |  main   |  做了出租车,小白做车回家
         *
         * Process finished with exit code 0
         */

        SmallUtil.printTimeAndThread(String.format("%s,小白做车回家",bus.join()));
    }
}

3.3、总结

CompletableFuture bus = CompletableFuture.supplyAsync(() -> {return “700路公交”;})
.applyToEither(CompletableFuture.supplyAsync(() -> {return “800路公交”;}),
firstComeBus -> {throw new RuntimeException(“700路公交没电了”);}return firstComeBus;})
.exceptionally(e -> {return “做了出租车”;}); 其中，exceptionally 可以写在中间，最后，等任意位置，代表着处理异常

总结

下面这张图是我自己学习的时候的一些总结，希望能对读者有一些帮助。
在这里插入图片描述

郑..方..醒
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CompletableFuture 使用详解
江城宴的博客
12-22 7186
CompletableFuture 使用详解 1、 runAsync 和 supplyAsync方法 CompletableFuture 提供了四个静态方法来创建一个异步操作。 public static CompletableFuture<Void> runAsync(Runnable runnable) public static CompletableFuture&...
使用CompletableFuture.supplyAsync实现异步操作
weixin_42488909的博客
07-07 4万+
如何使用CompletableFuture.supplyAsync实现异步操作（复杂型） 实现的代码封装在function中，也有简单的说明，如下： public static void useCompletableFuture_complicated() { // 这个方法时描述一般地使用CompletableFuture实现异步操作，即复杂的使用CompletableFuture实现异步操作 // 假设我们有一个Person名字List
CompletableFuture详细讲解
最新发布
YYVeryGood的博客
05-29 2279
是Java提供的一个实现Future接口的类，它不仅支持传统的Future接口方法，还引入了许多新的方法来支持回调、组合、处理异常等功能。通过这些方法，开发者可以更方便地编写异步代码。默认情况下，使用作为其默认的线程池。你可以自定义执行器来控制任务的执行方式：​​。
【Java 8 新特性】Java CompletableFuture supplyAsync()
猫巳的博客
05-18 3万+
Java CompletableFuture supplyAsync与 thenApply() 一起使用自定义执行器 Executor与 whenComplete() 一起使用与流(Stream)一起使用参考文献 在此页面上，我们将提供Java CompletableFuture.supplyAsync()示例。 supplyAsync()是Java 8中引入的CompletableFuture静态方法。 方法supplyAsync()完成在ForkJoinPool.commonPool()或给定的Exec
CompletableFuture之supplyAsync
m0_63285669的博客
01-31 4368
CompletableFuture之supplyAsync入门用法
CompletableFuture详解-初遇者-很细
码灵的博客
05-26 5629
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。代码涉及到lambda表达式用法，不熟悉的可先看下。
在Spring Boot2中使用CompletableFuture的方法教程
08-26
在Spring Boot 2中，`CompletableFuture`是一个强大的工具，用于构建异步、非阻塞的应用程序。结合`@Async`注解，可以轻松地实现并发处理，提高应用的性能和响应速度。本文将深入探讨如何在Spring Boot 2中有效地...
mina 入门 教程
12-17
本教程将带你一步步了解Mina的基本概念、架构以及如何使用Mina进行实际开发。 1. **Mina简介** Mina是基于Java的网络应用框架，支持TCP、UDP等多种传输协议。它为开发者提供了事件驱动、非阻塞I/O的网络编程模型，...
高级java教程
02-26
7. **并发编程**：Java并发库提供了一些高级工具，如ExecutorService、Future、Callable和CompletableFuture。我们将学习如何有效地管理并发任务，避免死锁和竞态条件。 8. **Java新特性**：随着Java版本的更新，...
Java高级实用教程
04-18
9. **并发编程**：Java并发库提供了高级并发工具，如Future、CompletableFuture、ForkJoinPool等，学习这些工具可以编写出高效的多线程应用。 10. **JVM内存模型**：理解Java虚拟机的内存区域，如堆、栈、方法区、...
清华大学 java教程
10-24
10. **Java高级特性**：如Lambda表达式、函数式接口、Optional类、模块化系统（Java 9+）、并发库的改进（Fork/Join框架、CompletableFuture）等。 11. **Java EE**：如果教程深入，可能会涉及到Web开发的基础，如...
CompletableFuture使用详解（全网看这一篇就行）
热门推荐
搬砖老农工的博客
04-02 7万+
CompletableFuture是jdk8的新特性。CompletableFuture实现了CompletionStage接口和Future接口，前者是对后者的一个扩展，增加了异步会点、流式处理、多个Future组合处理的能力，使Java在处理多任务的协同工作时更加顺畅便利。 1. supplyAsync supplyAsync是带有返回值的异步任务。它有如下两个方法，有一个是带有线程池的重载方法 // 带返回值异步请求，默认线程池 public static <U> Completa
【Java 8 新特性】Java CompletableFuture supplyAsync()详解
qq_45721579的博客
06-25 4192
【Java 8 新特性】Java CompletableFuture supplyAsync()
CompletableFuture详细介绍及方法使用示例(一)
Ascend1977的博客
05-25 8480
CompletableFuture是Java 8中引入的一种实现异步编程模型的方式，它是Future的扩展，提供了更强大、更灵活的功能。CompletableFuture可以表示两个异步任务之间的顺序关系或并行关系，同时提供了一些方便的工具方法来组合这些关系。
CompletableFuture 详解（一）：基本概念及用法
C18298182575的博客
04-06 3482
该示例的最终打印结果为11，可见程序在运行中，future1的结果计算出来后，会传递给通过thenApply连接的任务，从而产生future2的最终结果为1+10=11。同前面一组连接函数相比，thenCombine最大的不同是连接任务可以是一个独立的CompletableFuture（或者是任意实现了CompletionStage的类型），从而允许前后连接的两个任务可以并行执行（后置任务不需要等待前置任务执行完成），最后当两个任务均完成时，再将其结果同时传递给下游处理任务，从而得到最终结果。
Java：CompletableFuture的一些使用方法
東辰的博客
04-23 1824
定义 CompletableFuture，实现了Future和CompletionStage public class CompletableFuture<T> implements Future<T>, CompletionStage<T> { ... } 用法 supplyAsync supplyAsync(Supplier<U> supplier, Executor executor)异步，有返回值 Callable就是Supplier的一个实
CompletableFuture 详解（二）：supplyAsync / runAsync 实现原理 源码分析
tongtest的博客
07-25 4万+
前面CompletableFuture详解（一）：基本概念及用法讲了CompletableFuture的使用，从这篇开始，我们深入了解CompletableFuture的实现，以便于大家更深入的理解CompletableFuture是如何运行的，这也有利于大家正确地使用CompletableFuture。 本篇主要介绍 supplyAsync和runAsync的实现。 1、supplyAsync的实现 我们主要看入参为Supplier的版本。因为另外一个版本的supplyAsync函数，除了增加了自定
CompletableFuture.supplyAsync 异步调用,捕获异常并抛出到主线程
u011250186的博客
12-29 5154
CompletableFuture.supplyAsync 异步调用,捕获异常并抛出到主线程
CompletableFuture使用示例
qq_40708942的博客
08-02 2480
CompletableFuture的使用示例
CompletableFuture
09-12
CompletableFuture是Java 8引入的一个类，用于处理异步编程和并发任务。它提供了一种简单而强大的方式来处理异步操作，并在操作完成时执行回调。 CompletableFuture可以看作是一种可编程的Future，它可以用于执行和...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值