CompletableFuture 学习笔记

最新推荐文章于 2024-08-07 16:52:30 发布

Fire_Sky_Ho

最新推荐文章于 2024-08-07 16:52:30 发布

阅读量557

点赞数

分类专栏： Java SE/EE

本文链接：https://blog.csdn.net/Fire_Sky_Ho/article/details/115000793

版权

Java SE/EE 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

初次使用

【Java并发·03】CompletableFuture入门
【Java并发·04】CompletableFuture进阶
看完后加网上理解的笔记

初次使用

使用Future获得异步执行结果时，要么调用阻塞方法get()，要么轮询看isDone()是否为true，这两种方法都不是很好，因为主线程也会被迫等待。

从Java
8开始引入了CompletableFuture，它针对Future做了改进，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

俩静态supplyAsync方法，可以有返回结果，而另外俩runAsync是没有返回结果的

    public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier) {
        return asyncSupplyStage(asyncPool, supplier);
    }
   public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier,
                                                       Executor executor) {
        return asyncSupplyStage(screenExecutor(executor), supplier);
    }

下面是比对

方法名	描述
runAsync(Runnable runnable)	使用ForkJoinPool.commonPool()作为它的线程池执行异步代码。
runAsync(Runnable runnable, Executor executor)	使用指定的thread pool执行异步代码。
supplyAsync(Supplier<U> supplier)	使用ForkJoinPool.commonPool()作为它的线程池执行异步代码，异步操作有返回值
supplyAsync(Supplier<U> supplier, Executor executor)	使用指定的thread pool执行异步代码，异步操作有返回值

所有方法不带Async和带Async区别（重点理解）

async方法始终尝试取新线程执行方法，当然也可能使用当前线程
不带async方法则会从当前线程里取线程执行

前置工具类

一个小工具类打印线程信息和让线程睡眠

public class SmallTool {

    public static void sleepMillis(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void printTimeAndThread(String tag) {
        String result = new StringJoiner("\t\t")
                .add(new SimpleDateFormat("mm分ss秒SSS").format(new Date()))
                .add("线程id：" + String.valueOf(Thread.currentThread().getId()))
                .add("线程名：" + Thread.currentThread().getName())
                .add(tag)
                .toString();
        System.out.println(result);
    }

}

supplyAsync

场景1：

小白进入餐厅点菜
厨师有炒菜和打饭的过程，都是同一个人完成
在这期间小白再打王者
做好了开吃

public class _01_supplyAsync {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("小白进入餐厅");
        SmallTool.printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("厨师炒菜");
            SmallTool.sleepMillis(200);
            SmallTool.printTimeAndThread("厨师打饭");
            SmallTool.sleepMillis(100);
            return "番茄炒蛋 + 米饭 做好了";
        });

        SmallTool.printTimeAndThread("小白在打王者");
        //等待结果返回输出
        SmallTool.printTimeAndThread(String.format("%s ,小白开吃", cf1.join()));
    }
}

47分03秒085		线程id：1		线程名：main		小白进入餐厅
47分03秒086		线程id：1		线程名：main		小白点了 番茄炒蛋 + 一碗米饭
47分03秒150		线程id：1		线程名：main		小白在打王者
47分03秒150		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		厨师炒菜
47分03秒350		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		厨师打饭
47分03秒455		线程id：1		线程名：main		番茄炒蛋 + 米饭 做好了 ,小白开吃

使用supplyAsync返回结果，内置线程池，最后的语句使用了join阻塞等待返结果，不然main线程就直接结束了，看不到打印结果。
CompletableFuture 提供了 join() 方法，它的功能和 get() 方法是一样的，都是阻塞获取值，它们的区别在于 join()方法抛出的是uncheck异常（即未经检查的异常)，不会强制开发者抛出。

thenCompose

   public <U> CompletableFuture<U> thenComposeAsync(
        Function<? super T, ? extends CompletionStage<U>> fn) {
        return uniComposeStage(asyncPool, fn);
    }
    public interface Function<T, R> {
    	R apply(T t);
    }

允许将两个异步操作进行流水线，第一个操作完成时,将其结果作为参数传递给第二个操作，接收Function<入参类型，CompletionStage出参类型>参数

场景2：

小白进入餐厅点菜
厨师负责炒菜
炒完菜后，服务员才能打饭
在这期间小白再打王者
做好了开吃

下面的代码意思就是厨师炒完菜后返回结果给服务员，服务员才能去打饭。

public class _02_thenCompose {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("小白进入餐厅");
        SmallTool.printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("厨师炒菜");
            SmallTool.sleepMillis(200);
            return "番茄炒蛋";
        }).thenCompose(dish -> CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("服务员打饭");
            SmallTool.sleepMillis(100);
            return dish + " + 米饭";
        }));

        SmallTool.printTimeAndThread("小白在打王者");
        SmallTool.printTimeAndThread(String.format("%s 好了,小白开吃", cf1.join()));
    }

    /**
     * 嵌套调用，也能实现
     */
    private static void applyAsync() {
        SmallTool.printTimeAndThread("小白进入餐厅");
        SmallTool.printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("厨师炒菜");
            SmallTool.sleepMillis(200);
            CompletableFuture<String> race = CompletableFuture.supplyAsync(() -> {
                SmallTool.printTimeAndThread("服务员打饭");
                SmallTool.sleepMillis(100);
                return " + 米饭";
            });
            //重点是join()的使用，才能让打饭线程执行完在一起返回
            return "番茄炒蛋" + race.join();
        });

        SmallTool.printTimeAndThread("小白在打王者");
        SmallTool.printTimeAndThread(String.format("%s 好了,小白开吃", cf1.join()));
    }
}

结果，可以看出

25分14秒988		线程id：1		线程名：main		小白进入餐厅
25分14秒989		线程id：1		线程名：main		小白点了 番茄炒蛋 + 一碗米饭
25分15秒056		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		厨师炒菜
25分15秒057		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		服务员打饭
25分15秒057		线程id：1		线程名：main		小白在打王者
25分15秒061		线程id：1		线程名：main		番茄炒蛋 + 米饭 好了,小白开吃

thenCombine

    public <U,V> CompletableFuture<V> thenCombine(
        CompletionStage<? extends U> other,
        BiFunction<? super T,? super U,? extends V> fn) {
        return biApplyStage(null, other, fn);
    }
    public interface BiFunction<T, U, R> {
    	R apply(T t, U u);
    }

thenCombine 会把两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理，结果由thenCombine 第二个参数BiFunction返回，返回类型如下所示就是R

场景3：

小白进入餐厅点菜
厨师炒菜，同时服务员蒸饭
炒菜蒸饭完成了，服务员才打饭
在这期间小白再打王者
做好了开吃

代码意思就是把炒菜蒸饭任务结果一起返回，在进行拼接返回。

public class _03_thenCombine {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("小白进入餐厅");
        SmallTool.printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("厨师炒菜");
            SmallTool.sleepMillis(200);
            return "番茄炒蛋";
        }).thenCombine(CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("服务员蒸饭");
            SmallTool.sleepMillis(300);
            return "米饭";
        }), (dish, rice) -> {
            SmallTool.printTimeAndThread("服务员打饭");
            SmallTool.sleepMillis(100);
            return String.format("%s + %s 好了", dish, rice);
        });

        SmallTool.printTimeAndThread("小白在打王者");
        SmallTool.printTimeAndThread(String.format("%s ,小白开吃", cf1.join()));

    }

    /**
     * 用 applyAsync 也能实现
     */
    private static void applyAsync() {
        SmallTool.printTimeAndThread("小白进入餐厅");
        SmallTool.printTimeAndThread("小白点了 番茄炒蛋 + 一碗米饭");

        CompletableFuture<String> cf1 = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("厨师炒菜");
            SmallTool.sleepMillis(200);
            return "番茄炒蛋";
        });
        CompletableFuture<String> race = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("服务员蒸饭");
            SmallTool.sleepMillis(300);
            return "米饭";
        });
        SmallTool.printTimeAndThread("小白在打王者");

        String result = String.format("%s + %s 好了", cf1.join(), race.join());
        SmallTool.printTimeAndThread("服务员打饭");
        SmallTool.sleepMillis(100);

        SmallTool.printTimeAndThread(String.format("%s ,小白开吃", result));
    }
}

结果

50分03秒246		线程id：1		线程名：main		小白进入餐厅
50分03秒247		线程id：1		线程名：main		小白点了 番茄炒蛋 + 一碗米饭
56分47秒452		线程id：13		线程名：ForkJoinPool.commonPool-worker-1		厨师炒菜
56分47秒452		线程id：1		线程名：main		小白在打王者
56分47秒454		线程id：14		线程名：ForkJoinPool.commonPool-worker-2		服务员蒸饭
56分47秒754		线程id：14		线程名：ForkJoinPool.commonPool-worker-2		服务员打饭
56分47秒858		线程id：1		线程名：main		番茄炒蛋 + 米饭 好了 ,小白开吃

可以看出厨师炒菜和服务员蒸饭任务合并，两个都完成之后，在执行BiFunction实现类的内容，就是打饭，然后再返回BiFunction的结果

这个是视频里大佬总结的图，很形象

第一个在于开启异步任务
第二个在于异步任务连接
第三个在于异步任务结合

thenApply

把上一个异步执行的结果交给后面的Function，然后返回结果
场景4：

小白吃完饭要结账，开发票
服务员收款，这个或另外一个服务员开发票
回家

下面想要收款和开发票的服务员不同的线程可以用thenApplyAsync，但是用这个也不一定是新线程，原因最上面说过。

    public <U> CompletableFuture<U> thenApplyAsync(
        Function<? super T,? extends U> fn) {
        return uniApplyStage(asyncPool, fn);
    }

public class _01_thenApply {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("小白吃好了");
        SmallTool.printTimeAndThread("小白 结账、要求开发票");

        CompletableFuture<String> invoice = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("服务员收款 500元");
            SmallTool.sleepMillis(100);
            return "500";
        }).thenApply(money -> {
            SmallTool.printTimeAndThread(String.format("服务员开发票 面额 %s元", money));
            SmallTool.sleepMillis(200);
            return String.format("%s元发票", money);
        });

        SmallTool.printTimeAndThread("小白 接到朋友的电话，想一起打游戏");

        SmallTool.printTimeAndThread(String.format("小白拿到%s，准备回家", invoice.join()));
    }
}

25分22秒554		线程id：1		线程名：main		小白吃好了
25分22秒556		线程id：1		线程名：main		小白 结账、要求开发票
25分22秒630		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		服务员收款 500元
25分22秒631		线程id：1		线程名：main		小白 接到朋友的电话，想一起打游戏
25分22秒737		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		服务员开发票 面额 500元
25分22秒938		线程id：1		线程名：main		小白拿到500元发票，准备回家

applyToEither

最快返回输出的线程结果作为下一次任务的输入

    public <U> CompletableFuture<U> applyToEither(
        CompletionStage<? extends T> other, Function<? super T, U> fn) {
        return orApplyStage(null, other, fn);
    }

场景5：

张三吃完饭，出餐厅，到公交等两路公交
哪个先到先上哪个
上车

下面就是700路和800路哪个先到了，就把结果赋给firstComeBus ，然后返回firstComeBus

public class _02_applyToEither {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("张三走出餐厅，来到公交站");
        SmallTool.printTimeAndThread("等待 700路 或者 800路 公交到来");

        CompletableFuture<String> bus = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("700路公交正在赶来");
            SmallTool.sleepMillis(100);
            return "700路到了";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("800路公交正在赶来");
            SmallTool.sleepMillis(200);
            return "800路到了";
        }), firstComeBus -> firstComeBus);

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

40分35秒908		线程id：1		线程名：main		张三走出餐厅，来到公交站
40分35秒909		线程id：1		线程名：main		等待 700路 或者 800路 公交到来
40分35秒982		线程id：11		线程名：ForkJoinPool.commonPool-worker-1		700路公交正在赶来
40分35秒983		线程id：12		线程名：ForkJoinPool.commonPool-worker-2		800路公交正在赶来
40分36秒086		线程id：1		线程名：main		700路到了,小白坐车回家

exceptionally

当运行出现异常时,调用该方法可进行一些补偿操作,如设置默认值，就是try catch简化版

场景6：

跟场景5一样，不过在做700路时撞树了
改叫出租车

    public CompletableFuture<T> exceptionally(
        Function<Throwable, ? extends T> fn) {
        return uniExceptionallyStage(fn);
    }

下面代码就是在搭700路时，抛异常，exceptionally输出异常

public class _03_exceptionally {
    public static void main(String[] args) {
        SmallTool.printTimeAndThread("张三走出餐厅，来到公交站");
        SmallTool.printTimeAndThread("等待 700路 或者 800路 公交到来");

        CompletableFuture<String> bus = CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("700路公交正在赶来");
            SmallTool.sleepMillis(100);
            return "700路到了";
        }).applyToEither(CompletableFuture.supplyAsync(() -> {
            SmallTool.printTimeAndThread("800路公交正在赶来");
            SmallTool.sleepMillis(200);
            return "800路到了";
        }), firstComeBus -> {
            SmallTool.printTimeAndThread(firstComeBus);
            if (firstComeBus.startsWith("700")) {
                throw new RuntimeException("撞树了……");
            }
            return firstComeBus;
        }).exceptionally(e -> {
            SmallTool.printTimeAndThread(e.getMessage());
            SmallTool.printTimeAndThread("小白叫出租车");
            return "出租车 叫到了";
        });

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