ComplatableFuture初解使用

一、介绍

CompletableFuture是Java中的一个类，用于进行异步编程。它提供了一套强大的方法，可以方便地管理异步操作、处理结果和错误等。

二、方法

方法	功能	入参	出参
`completedFuture(T value)`	创建一个已经完成结果的`CompletableFuture`对象	无	有
`runAsync(Runnable runnable)`	启动异步任务	无	无
`supplyAsync(Supplier<U> supplier)`	启动异步任务	无	有
`thenApply(Function<T, U> function)`	转换一个`CompletableFuture`对象及内容	有	有
`thenApplyAsync(Function<T, U> fn)`	启动异步任务，转换一个`CompletableFuture`对象及内容	有	有
`thenAccept(Consumer<T> consumer)`	消费一个`CompletableFuture`对象的内容	有	无
`thenAcceptAsync(Consumer<T> action, Executor executor`	启动异步任务，消费一个`CompletableFuture`对象的内容	有	无
`thenRun(Runnable runnable)`	当之前的任务完成后，执行任务	无	无
`thenRunAsync(Runnable action, Executor executor)`	当之前的任务完成后，执行异步任务	无	无
`thenCompose(Function<T, CompletableFuture<U>> function)`	将一个`CompletableFuture`对象内容，转换为一个新的`CompletableFuture`对象	有	有
`exceptionally(Function<Throwable, T> function)`	当前面`CompletableFuture`对象的任务出现异常时，会进入此方法	有	有
`handle(BiFunction<T, Throwable, U> biFunction)`	当前面`CompletableFuture`对象的任务完成，或者出现异常时，会进入此方法	有	有
`allOf(CompletableFuture<?>... cfs)`	等内部所有`CompletableFuture`对象的任务完成，返回一个新的`CompletableFuture`对象	无	有

这些方法提供了灵活和强大的功能，可用于编写复杂的异步任务，并管理它们的结果和异常。

主要可以看到，只要方法名上包括Async的，都可以指定一个线程池，启动一个异步任务。

而then开头的方法名，则可以认为是上一个任务结束后进行的任务调用。

三、示例使用

下面就是一些测试使用的例子了

这是一个输出打印工具类，里面有线程名信息

package com.banmoon.complatablefuture;

import cn.hutool.core.date.DateUtil;

import java.util.concurrent.TimeUnit;

public class ThreadUtil {

    public static void printThread(Object o) {
        System.out.println("线程名：[" + Thread.currentThread().getName() +  "] 时间：[" + DateUtil.now() + "]" + o);
    }

    public static void sleepSecond(long second) {
        try {
            TimeUnit.SECONDS.sleep(second);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

代码

package com.banmoon.complatablefuture;

import org.junit.Test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CompletableFutureTest {

    public static final ExecutorService threadPool = Executors.newFixedThreadPool(5);

    @Test
    public void test01() {
        CompletableFuture<String> completableFuture = CompletableFuture.supplyAsync(() -> {
            ThreadUtil.printThread("测试");
            return "结果";
        });
        ThreadUtil.printThread("等待结果：" + completableFuture.join());
    }

    @Test
    public void test02() {
        CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
            ThreadUtil.printThread("测试");
        });
        ThreadUtil.printThread("等待结果：" + completableFuture.join());
    }

    @Test
    public void test03() {
        CompletableFuture<String> completableFuture = CompletableFuture
                .completedFuture("结果")
                .thenApply(t -> {
                    ThreadUtil.printThread("测试1");
                    return t + "1";
                }).thenApplyAsync(t -> {
                    ThreadUtil.printThread("测试2");
                    return t + "2";
                }, threadPool);
        ThreadUtil.printThread("等待结果：" + completableFuture.join());
    }

    @Test
    public void test04() {
        CompletableFuture<Void> completableFuture = CompletableFuture
                .completedFuture("结果")
                .thenAccept(t -> {
                    ThreadUtil.printThread(t + "1");
                });
        CompletableFuture<Void> completableFuture2 = CompletableFuture
                .completedFuture("结果")
                .thenAcceptAsync(t -> {
                    ThreadUtil.printThread(t + "2");
                }, threadPool);
    }

    @Test
    public void test05() {
        CompletableFuture<Void> completableFuture = CompletableFuture
                .completedFuture("结果")
                .thenRun(() -> {
                    ThreadUtil.printThread("测试1");
                }).thenRunAsync(() -> {
                    ThreadUtil.printThread("测试2");
                }, threadPool);
    }

    @Test
    public void test06() {
        CompletableFuture<String> future = CompletableFuture
                .completedFuture("结果")
                .thenCompose(t -> {
                    ThreadUtil.printThread("测试");
                    return CompletableFuture.completedFuture(t + "1");
                });
        ThreadUtil.printThread(future.join());
    }

    @Test
    public void test07() {
        CompletableFuture<String> future = CompletableFuture
                .supplyAsync(() -> {
                    ThreadUtil.printThread("测试");
                    int i = 1 / 0;
                    return i + "";
                }, threadPool).exceptionally(e -> {
                    ThreadUtil.printThread("失败，" + e.getMessage());
                    return "失败";
                });
        ThreadUtil.printThread(future.join());
    }

    @Test
    public void test08() {
        CompletableFuture<String> future = CompletableFuture
                .supplyAsync(() -> {
                    ThreadUtil.printThread("测试1");
                    return "结果";
                }, threadPool).handle((str, e) -> {
                    ThreadUtil.printThread("处理2");
                    return str + "2";
                });
        ThreadUtil.printThread(future.join());
    }

    @Test
    public void test10() {
        CompletableFuture<Void> completableFuture = CompletableFuture.allOf(CompletableFuture.supplyAsync(() -> {
            ThreadUtil.sleepSecond(1);
            ThreadUtil.printThread("测试1");
            return "测试1";
        }, threadPool), CompletableFuture.supplyAsync(() -> {
            ThreadUtil.sleepSecond(2);
            ThreadUtil.printThread("测试2");
            return "测试2";
        }, threadPool), CompletableFuture.supplyAsync(() -> {
            ThreadUtil.sleepSecond(3);
            ThreadUtil.printThread("测试3");
            return "测试3";
        }, threadPool)).thenRunAsync(() -> {
            ThreadUtil.printThread("测试4");
        }, threadPool);

        System.out.println(completableFuture.join());
    }

}