线程回顾

1)、继承 Thread
2)、实现 Runnable 接口
3)、实现 Callable 接口 + FutureTask (可以拿到返回结果，可以处理异常)
4)、线程池

方式1 和方式2：主进程无法获取线程的运算结果。不适合当前场景
方式3：主进程可以获取线程的运算结果，但是不利于控制服务器中的线程资源。可以导致服务器资源耗尽（若给每个请求都开启一个线程进行处理的话）。
方式4：通过如下两种方式初始化线程池

Executors.newFiexedThreadPool(3); // 使用Executors工具类
//或者使用原生方法创建线程池
new ThreadPoolExecutor(corePoolSize, maximumPoolSize, keepAliveTime, 
                       TimeUnit unit, workQueue, threadFactory, handler);

通过线程池性能控制资源，稳定性能，也可以获取执行结果，并捕获异常。但是，在业务复杂情况下，一个异步调用可能会依赖于另一个异步调用的执行结果。

使用线程池的原因

降低资源的消耗
通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
提高响应速度

因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无需创建新的线程就能执行

提高线程的可管理性

线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

CompletableFuture异步编排

业务场景:
查询商品详情页的逻辑比较复杂，有些数据还需要远程调用，必然需要花费更多的时间。

假如商品详情页的每个查询，需要如下标注的时间才能完成那么，用户需要 5.5s 后才能看到商品详情页的内容。很显然是不能接受的。如果有多个线程同时完成这 6 步操作，也许只需要 1.5s 即可完成响应。

Future 是 Java 5 添加的类，用来描述一个异步计算的结果。你可以使用isDone方法检查计算是否完成，或者使用get阻塞住调用线程，直到计算完成返回结果，你也可以使用cancel 方法停止任务的执行。

虽然Future以及相关使用方法提供了异步执行任务的能力，但是对于结果的获取却是很不方便，只能通过阻塞或者轮询的方式得到任务的结果。阻塞的方式显然和我们的异步编程的初衷相违背，轮询的方式又会耗费无谓的 CPU 资源，而且也不能及时地得到计算结果，为什么不能用观察者设计模式当计算结果完成及时通知监听者呢?
在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture，提供了非常强大的 Future 的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合 CompletableFuture 的方法。 CompletableFuture 类实现了 Future 接口，所以你还是可以像以前一样通过get方法阻塞或者轮询的方式获得结果，但是这种方式不推荐使用。

1、创建异步对象
CompletableFuture 提供了四个静态方法
1、runXxxx 都是没有返回结果的，supplyXxx 都是可以获取返回结果的
2、可以传入自定义的线程池，否则就用默认的线程池;

2、计算完成时回调方法

whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况。 whenComplete 和 whenCompleteAsync 的区别:
whenComplete:是执行当前任务的线程执行继续执行 whenComplete 的任务。
whenCompleteAsync:是执行把 whenCompleteAsync 这个任务继续提交给线程池来进行执行。

public class CompletableFutureTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("开启线程：" + Thread.currentThread().getName());
            int i = 10 / 2;
            int j = 10 / 0;
            return i;
        }).whenComplete(new BiConsumer<Integer, Throwable>() {
            // whenComplete 可以接收返回值和异常，但不能返回任何信息
            @Override
            public void accept(Integer result, Throwable exception) {
                System.out.println("处理结果是：" + result);
                System.out.println("异常：" + exception);
            }
        }).exceptionally(new Function<Throwable, Integer>() {
            // exceptionally 可以接收异常并提供返回值
            @Override
            public Integer apply(Throwable exception) {
                return 0;
            }
        });
        // get方法会阻塞主线程直到返回结果
        System.out.println("线程返回的结果是：" + future.get());
    }
}
/*
开启线程：ForkJoinPool.commonPool-worker-1
处理结果是：null
异常：java.util.concurrent.CompletionException: java.lang.ArithmeticException: / by zero
线程返回的结果是：0
*/

3、handle方法
handle方法可以接收返回值和异常作为参数，并提供返回值（相当于调用whenComplete + exceptionally）。

线程串行化方法

thenApply 方法:当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。（接收前一个返回结果，自己也返回结果）
thenAccept 方法:消费处理结果。接收任务的处理结果，并消费处理，无返回结果。（接收返回结果，自己不返回结果）
thenRun 方法:只要上面的任务执行完成，就开始执行 thenRun，只是处理完任务后，执行 thenRun 的后续操作（不接收返回值且自己也没有返回结果）

带有 Async 默认是异步执行的。同之前。以上都要前置任务成功完成。
Function<? super T,? extends U>
T：上一个任务返回结果的类型
U：当前任务返回值类型

两任务组合：都要完成

两个任务必须都要完成才会触发当前任务

thenCombine:组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值
thenAcceptBoth:组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。
runAfterBoth:组合两个 future，不需要获取 future 的结果，只需两个 future 处理完任务后，处理该任务。

public void testRunAfterBoth() {
    CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(() -> {
        System.out.println("线程01");
        return null;
    });
    CompletableFuture<Void> future2 = CompletableFuture.supplyAsync(() -> {
        System.out.println("线程02");
        return null;
    });

    future1.runAfterBoth(future2, new Runnable() {
        @Override
        public void run() {
            System.out.println("线程01、线程02都已运行结束");
        }
    });
}

两任务组合：一个完成

当两个任务中，任意一个 future 任务完成的时候，执行任务。

applyToEither:两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。
acceptEither:两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。
runAfterEither:两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返回值。

多任务组合

allOf:等待所有任务完成
anyOf:只要有一个任务完成

public void testAllOf() throws ExecutionException, InterruptedException {

    CompletableFuture<Void> all = CompletableFuture.allOf(
        futureImg,
        futureAttr,
        futureDesc);

    all.get(); // 传入的方法会同时调用，只需阻塞等待最长任务执行结束
}

Java-interview