结合电商模式打造校园交易平台之CompletableFuture异步编程篇（全文总共13万字，超详细）

CompletableFuture异步编程

多线程

首先我们回顾一下初始化线程的四种方式：

1、继承Thread类
2、实现Runnable结构
3、实现Callable接口+FutureTask(可以拿到返回结果，可以处理异常)，Callable支持泛型，泛型类型即返回结果类型。FutureTask的get()方法是阻塞等待当前线程任务执行完成，拿到返回值

4、线程池：当前系统中线程池只能有一两个，异步任务交由线程池自己去选择线程执行

1和2：主进程无法获取线程的运算结果

3：主进程可以获取当前线程的运算结果，但是不利于控制服务器种的线程资源，可能导致服务器资源耗尽

4：线程池执行异步任务性能稳定，也可以选择获取执行结果（可以不获取）并捕获异常。但是，在业务复杂情况下，一个异步调用可能会依赖于另一个异步调用的执行结果。可以通过如下两种方式初始化线程池

Executors.newFixedThreadPool(3);
//或
new ThreadPollExecutor(corePoolSize,maximumPoolSize,keepAliveTime,TimeUnit,unit,workQueue,threadFactory,handler);

四种方式代码如下：

public class ThreadTest {
    //一般一个系统里面只有一个线程池
	public static ExecutorService service = Executors.newFixedThreadPool(10);
	public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main.............start.......");
        /**
         * 1、继承Thread
         * 2、实现Runnable
         * 3、实现Callable接口+FutureTask(可以拿到返回结果，可以处理异常)
         * 4、线程池=ExecutorService
         *      让线程池直接执行任务
         *      service.execute(new Runnable01());execute方法只能传入Runnable接口，所以它没有返回值，但是submit可以传入Runnable（还可以传如一个T 接收返回结果），也可以传入Callable，所以submit方法是有一个返回值（Future类型）的
         *      创建：Executors或者自定义线程池
         * 区别：
         *  1、2不能得到返回值。3可以获取返回值
         *  1、2、3都不能控制资源
         *  4可以控制资源，性能稳定。
         */
//当前系统中池只有一两个，每个异步任务，提交给线程池让他自己去执行就行
        
//        1、继承Thread
//        Thread01 thread01 = new Thread01();
//        thread01.start();//启动线程
    
//        2、实现Runnable
//        Runnable01 runnable01 = new Runnable01();
//        new Thread(runnable01).start();
 
//        3、实现Callable接口+FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        //阻塞等待整个线程执行完成，获取返回结果
        Integer integer = futureTask.get();
//        4、线程池
        service.execute(new Runnable01());
        System.out.println("main.............end......."+integer);
    }
	public static class Thread01 extends Thread{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("当前运行结果:" + i);
        }
    }
	public static class Runnable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("当前运行结果:" + i);
        }
    }
	public static class Callable01 implements Callable<Integer>{
        @Override
        public Integer call() throws Exception {
            System.out.println("当前线程："+Thread.currentThread().getId());
            int i = 10/2;
            System.out.println("当前运行结果:" + i);
            return i;
        }
    }
}

线程池

我们以后在实际业务中前三种启动线程的方式都不用，我们将所有的多线程异步任务都交给线程池执行。

线程池(ThreadPoolExecutor)的继承机构：

顶级接口Executor: 定义了execute(Runnbale command)方法

​ 子接口ExecutorService

​ 最常用实现类:ThreadPoolExecutor

如果调用ThreadPoolExecutor实现类的构造器创建线程池时并不会马上创建线程，只有当调用其execute方法时才会去创建线程，类似于延时加载（创建线程）。

使用线程池的好处：

• 降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗
• 提高响应速度 ：因为线程池中的线程数没有超过线程池的最大上限时，有的线程处于等待分配任务的状态，当任务来时无须创建新的线程就能执行
• 提高线程的可管理性 ：线程池会根据当前系统特点对池内的线程进行优化处理，减少创建和销毁线程带来的系统开销。无限的创建和销毁线程不仅消耗系统资源，还降低系统的稳定性，使用线程池进行统一分配

我们这里再回顾一下线程池的七大参数

1. corePoolSize： 核心线程数[一直存在，除非设置核心线程的超时时间allowCoreThreadTimeOut]；核心线程数的意思就是线程池创建好以后就准备就绪的线程数量，核心线程如果是空闲的就会等待接收异步任务去执行。核心线程数是多少，线程工厂就会创建几个线程并且start。
2. maximumPoolSize： 最大线程数量，用于控制线程资源
3. keepAliveTime: 存活时间。如果当前正在运行的线程数量大于core数量，那么就会释放空闲的线程(释放数量=maximumPoolSize-corePoolSize)。释放条件：只要线程空闲时间大于指定的keepAliveTime;
4. unit: 线程空闲时间的时间单位
5. BlockingQueue workQueue： 工作队列。如果任务有很多，就会将多的任务放在队列里面。只要有线程空闲，就会去队列里面取出新的任务继续执行
6. ThreadFactory： 创建线程的工厂
7. RejectedExecutionHandler handler： 拒绝策略：如果队列满了，就会按照我们指定的拒绝策略，拒绝执行新的任务。
   • AbortPolicy ：抛出运行时异常RejectedExecutionException。这种策略丢弃任务，并抛出异常。（jdk默认策略）
   • CallerRunsPolicy : 线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制，能够减缓新任务的提交速度。
   • DiscardOldestPolicy（弃老策略）jdk：如果执行程序尚未关闭，则位于工作队列头部的任务将被删除，然后重试执行程序。
   • DiscardPolicy ：发生拒绝策略时，不触发任何动作

线程池的工作顺序

1. 线程池创建，执行execut方法后准备好core数量的核心线程，准备接受任务
2. 新任务进来，如果有空闲的core线程那么就执行任务。core如果满了，就将再进来的任务放入阻塞队列中。空闲的core就会自己去阻塞队列获取任务执行
3. 阻塞队列满了，就直接开新线程执行（执行的是最近来的新任务，而不是阻塞队列中的任务），最大只能开到max指定的数量
4. max满了就用RejectedExecutionHandler拒绝任务
5. max都执行完成，有很多空闲，在指定的时间keepAliveTime以后，释放空闲的线程(max-core)。

**例子：**一个线程池 core 7, max 20, queue 50, 100并发进来怎么分配的

7个会立即执行。50个进入队列，再开13个线程进行执行，剩下30个就用拒绝策略。

以下为自定义线程池的过程：

     ThreadPoolExecutor executor = new ThreadPoolExecutor(
                5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(100000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy());

常见的4种线程池

newSingleThreadExecutor： 创建一个单线程化的线程池，他只会用唯一的工作线程来执行任务，保证所有任务。后台从队列里面获取任务，挨个执行。

newFixedThreadPool： 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。固定大小，core=max，表示线程都不可回收。

newCachedThreadPool： 创建一个可缓存的线程池，如果线程池长度超过处理需要，可灵活回收空闲线程。它的core是0，表示所有线程都可以回收。

newScheduledThreadPool： 创建一个定长线程池。支持定时（设置一个延时时间表示多长时间之后执行任务）和周期性地执行任务。

但是这里我们注意，在阿里的开发手册里面明确提出不要使用这四种线程池，因为前两种的阻塞队列是无界队列，可能会出现OOM。后两种的maxmum都是无上限的，也可能会报OOM。我们在开发中使用线程池**最好是new ThreadPoolExecutor(…)；**然后根据业务需要自行设置这七大参数。

CompletableFuture组合式异步编程

注意事项：使用异步编排CompletableFuture必须调用它的affof()方法，否则可能出现线程池执行过程中线程被挂起的情况，也就会导致任务执行阻塞。

在我们的项目中，查询商品详情页的逻辑比较复杂，有些数据甚至涉及到了远程调用（极其花费时间），具体查询数据流程如下：

1. 获取sku的基本信息 0.5s
2. 获取sku的图片信息 0.5s
3. 获取sku的促销信息 1s
4. 获取spu的所有销售属性 1s
5. 获取规格参数组及组下的规格参数 1.5s
6. spu详情 1s（以上所有时间只是用于描述问题）

这里如果是单线程同步执行的话，访问我们的商品详情页需要足足5.5s。但是多线程下可能只需要1.5s即可（即执行时间最长的那个任务所需时间）。但我们这里的业务又有所不同： 1、2、3可以异步完成，4、5、6依赖于1完成之后的结果，4、5、6又可以异步完成，所以我们需要使用CompletableFuture进行异步编排 ，以使得456任务在获取到1执行完成之后的结果之后才异步执行。

下面我们就使用异步编程达到这一目标。

首先我们要学会JUC包下的CompletableFuture如何使用的，这里首先看一下它的源码，了解其继承结构：

public class CompletableFuture<T> implements Future<T>, CompletionStage<T> 
public interface Future<V> {
public interface CompletionStage<T> {

可以看到其实现了Future接口，前面我们说创建线程的第三个方法实现Callable接口时就提到了其需要与FutrueTask联合使用，FutureTask也实现了Future这个接口。想要用好CompletableFuture，我们就需要了解Future这个接口，因为CompletableFuture（JDK8）是在Future（JDK5）基础上进行改进的，下面为拓展内容，想直接跟项目走的同学可以先行跳过。

Futrue接口的原理：

为了更快的了解Future模式，我们先来看一个生活中的例子。

场景1：
午饭时间到了，同学们要去吃饭了，小王（红色）下楼，走了20分钟，来到了肯德基，点餐，排队，吃饭一共花了20分钟，又花了20分钟走回公司继续工作，合计1小时。

场景2：
午饭时间到了，同学们要去吃饭了，小王点了个肯德基外卖，一分钟它就拿到了一个订单（虽然订单不能当饭吃，但是有了订单，还怕吃不上饭嘛）。接着小王可以继续干活，30分钟后，外卖到了，接着小王花了10分钟吃饭，接着又可以继续工作了，成功的卷到了隔壁红色的小王。

很明显，在这2个场景中，红色的小王的工作时间更加紧凑，特别是那些排队的时间都可以让外卖员去干，因此可以更加专注于自己的本职工作。聪明的你应该也已经体会到了，场景1就是典型的函数同步调用，而场景2是典型的异步调用。

而场景2的异步调用，还有一个特点，就是它拥有一个返回值，这个返回值就是我们的订单。这个订单很重要，凭借着这个订单，我们才能够取得当前这个调用所对应的结果。

这里的订单就如同Future模式中的Future，这是一个合约，一份承诺。虽然订单不能吃，但是手握订单，不怕没吃的，虽然Future不是我们想要的结果，但是拿着Future就能在将来得到我们想要的结果。

因此，Future模式很好的解决了那些需要返回值的异步调用。

Future模式中的主要角色

一个典型的Future模式由以下几个部分组成：

• Main：系统启动，调用Client发出请求

• Client：返回Data对象，立即返回FutureData，并开启ClientThread线程装配RealData

• Data：返回数据的接口

• FutureData：Future数据，构造很快，但是是一个虚拟的数据，需要装配RealData，好比一个订单

• RealData：真实数据，其构造是比较慢的，好比上面例子中的肯德基午餐。

它们之间的相互关系如下图：

其中值得注意是Data，RealData和FutureData。这是一组典型的代理模式，Data接口表示对外数据，RealData表示真实的数据，就好比午餐，获得它的成本比较高，需要很多时间；相对的FutureData作为RealData的代理，类似于一个订单/契约，通过FutureData，可以在将来获得RealData。

因此Future模式本质上是代理模式的一种实际应用。

实现一个简单的Future模式

根据上面的设计，让我们来实现一个简单的代理模式吧！

首先是Data接口，代表数据：

public interface Data {
    public String getResult ();
}

接着是FutureData，也是整个Future模式的核心：

public class FutureData implements Data {
    // 内部需要维护RealData
    protected RealData realdata = null;          
    protected boolean isReady = false;
    public synchronized void setRealData(RealData realdata) {
        if (isReady) { 
            return;
        }
        this.realdata = realdata;
        isReady = true;
        //RealData已经被注入，通知getResult()
        notifyAll();                            			
    }
    //会等待RealData构造完成
    public synchronized String getResult() {        	
        while (!isReady) {
            try {
                //一直等待，直到RealData被注入
                wait();                        			
            } catch (InterruptedException e) {
            }
        }
        //真正需要的数据从RealData获取
        return realdata.result;                    		
    }
}

下面是RealData：

public class RealData implements Data {
    protected final String result;
    public RealData(String para) {
        StringBuffer sb=new StringBuffer();
        //假设这里很慢很慢，构造RealData不是一个容易的事
        result =sb.toString();
    }
    public String getResult() {
        return result;
    }
}

然后从Client得到Data：

public class Client {
    //这是一个异步方法，返回的Data接口是一个Future
    public Data request(final String queryStr) {
        final FutureData future = new FutureData();
        new Thread() {                                      
            public void run() {                    	
                // RealData的构建很慢，所以在单独的线程中进行
                RealData realdata = new RealData(queryStr);
                //setRealData()的时候会notify()等待在这个future上的对象
                future.setRealData(realdata);
            }                                               
        }.start();
        // FutureData会被立即返回，不会等待RealData被构造完
        return future;                        		
    }
}

最后一个Main函数，把所有一切都串起来：

public static void main(String[] args) {
    Client client = new Client();
    //这里会立即返回，因为得到的是FutureData而不是RealData
    Data data = client.request("name");
    System.out.println("请求完毕");
    try {
        //这里可以用一个sleep代替了对其他业务逻辑的处理
        //在处理这些业务逻辑的过程中，RealData被创建，从而充分利用了等待时间
        Thread.sleep(2000);
    } catch (InterruptedException e) {
    }
    //使用真实的数据，如果到这里数据还没有准备好，getResult()会等待数据准备完，再返回
    System.out.println("数据 = " + data.getResult());
}

这是一个最简单的Future模式的实现，虽然简单，但是已经包含了Future模式中最精髓的部分。对大家理解JDK内部的Future对象，有着非常重要的作用。

Java中的Future模式

Future模式是如此常用，在JDK内部已经有了比较全面的实现和支持。下面，让我们一起看看JDK内部的Future实现：

首先，JDK内部有一个Future接口，这就是类似前面提到的订单，当然了，作为一个完整的商业化产品，这里的Future的功能更加丰富了，除了get()方法来获得真实数据以外，还提供一组辅助方法，比如：

• cancel()：如果等太久，你可以直接停止执行这个任务

• isCancelled()：任务是不是已经取消了

• isDone()：检查计算是否完成，即线程执行的任务是不是已经完成了

• get()：有2个get()方法，不带参数的表示无穷等待，或者你可以只等待给定时间，它是阻塞住其调用线程去等待异步线程执行结果

下面代码演示了这个Future的使用方法：

    //异步操作 可以用一个线程池
    ExecutorService executor = Executors.newFixedThreadPool(1);
    //执行FutureTask，相当于上例中的 client.request("name") 发送请求
    //在这里开启线程进行RealData的call()执行
    Future<String> future = executor.submit(new RealData("name"));
    System.out.println("请求完毕，数据准备中");
    try {
        //这里依然可以做额外的数据操作，这里使用sleep代替其他业务逻辑的处理
        Thread.sleep(2000);
    } catch (InterruptedException e) {
    }
    //如果此时call()方法没有执行完成，则依然会等待
    System.out.println("数据 = " + future.get());

整个使用过程非常简单，下面我们来分析一下executor.submit()里面究竟发生了什么：

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    // 根据Callable对象，创建一个RunnableFuture，这里其实就是FutureTask
    RunnableFuture<T> ftask = newTaskFor(task);
    //将ftask推送到线程池
    //在新线程中执行的，就是run()方法，在下面的代码中有给出
    execute(ftask);
    //返回这个Future，将来通过这个Future就可以得到执行的结果
    return ftask;
}
protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
    return new FutureTask<T>(callable);
}

最关键的部分在下面，FutureTask作为一个线程单独执行时，会将结果保存到outcome中，并设置任务的状态,下面是FutureTask的run()方法：

从FutureTask中获得结果的实现如下：

public V get() throws InterruptedException, ExecutionException {
    int s = state;
    //如果没有完成，就等待，回到用park()方法阻塞线程
    //同时，所有等待线程会在FutureTask的waiters字段中排队等待
    if (s <= COMPLETING)
        s = awaitDone(false, 0L);
    return report(s);
}
private V report(int s) throws ExecutionException {
    //outcome里保存的就是最终的计算结果
    Object x = outcome;
    if (s == NORMAL)
        //正常完成，就返回outcome
        return (V)x;
    //如果没有正常完成， 比如被用户取消了，或者有异常了，就抛出异常
    if (s >= CANCELLED)
        throw new CancellationException();
    throw new ExecutionException((Throwable)x);
}

到这里你大致应该就对Future的原理有了一定的了解了，下面就开始学习它的加强版。

Future模式的高阶版本之CompletableFuture

Future模式虽然好用，但也有一个问题，那就是将任务提交给线程后，调用线程并不知道这个任务什么时候执行完，如果执行调用get()方法或者isDone()方法判断，可能会进行不必要的等待，那么系统的吞吐量很难提高。

为了解决这个问题，JDK对Future模式又进行了加强，创建了一个CompletableFuture，它可以理解为Future模式的升级版本，它最大的作用是提供了一个回调机制，可以在任务完成后，自动回调一些后续的处理，这样，整个程序可以把“结果等待”完全给移除了。

下面来看一个简单的例子：

在这个例子中，首先以getPrice()为基础创建一个异步调用，接着使用thenAccept()方法，设置了一个后续的操作，也就是当getPrice()执行完成后的后续处理。

不难看到，CompletableFuture比一般的Future更具有实用性，因为它可以在Future执行成功后，自动回调进行下一步的操作，因此整个程序不会有任何阻塞的地方（也就是说你不用去到处等待Future的执行，而是让Future执行成功后，自动来告诉你） 。

以上面的代码为例，CompletableFuture之所有会有那么神奇的功能，完全得益于AsyncSupply类（由上述代码中的supplyAsync()方法创建）。

AsyncSupply在执行时，如下所示：

    public void run() {
        CompletableFuture<T> d; 
        Supplier<T> f;
        if ((d = dep) != null && (f = fn) != null) {
            dep = null; fn = null;
            if (d.result == null) {
                try {
                    //这里就是你要执行的异步方法
                    //结果会被保存下来，放到d.result字段中
                    d.completeValue(f.get());
                } catch (Throwable ex) {
                    d.completeThrowable(ex);
                }
            }
            //执行成功了，进行后续处理，在这个后续处理中，就会调用thenAccept()中的消费者
            //这里就相当于Future完成后的通知
            d.postComplete();
        }
    }

继续看d.postComplete()，这里会调用后续一系列操作

final void postComplete() {
                //省略部分代码，重点在tryFire()里
                //在tryFire()里，真正触发了后续的调用，也就是thenAccept()中的部分
                f = (d = h.tryFire(NESTED)) == null ? this : d;
}

这里就介绍完了前沿知识，下面我们回到我们的项目：

谷粒商城项目使用CompletableFuture

创建异步对象

runAsync 和 supplyAsync方法

CompletableFuture 提供了四个静态方法来创建一个异步对象。

public static CompletableFuture<Void> runAsync(Runnable runnable)
public static CompletableFuture<Void> runAsync(Runnable runnable, Executor executor)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)
public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor)

没有指定Executor的方法会使用ForkJoinPool.commonPool() 作为它的线程池执行异步代码。如果指定线程池，则使用指定的线程池运行。以下所有的方法都类同。

• runAsync方法不支持返回值。
• supplyAsync可以支持返回值，使用fet获取返回结果

为什么一个支持返回值一个不支持呢？看下其参数，一个Runnable接口一个Supplier接口，这两个一个是直接run方法运行，一个是get方法会返回一个值。后文的接收参数无返回值用的Consumer接口，accept方法只接收参数不返回参数。但这个返回值只是给CompletableFuture这个类的泛型赋值，泛型会决定方法究竟有无具体有意义的返回值，但它们最后都会返回一个CompletableFuture对象

测试代码如下：

public static void main(String[] args) throws ExecutionException, InterruptedException {
    System.out.println("main.............start.......");
//        CompletableFuture future = CompletableFuture.runAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("当前运行结果:" + i);
//        }, executor);
	CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
        System.out.println("当前线程：" + Thread.currentThread().getId());
        int i = 10 / 2;
        System.out.println("当前运行结果:" + i);
        return i;
    }, executor);
    Integer integer = future.get();
    System.out.println("main.............end......."+integer);
}

计算结果完成时的回调方法

当CompletableFuture的计算结果完成或者抛出异常的时候，可以通过调用的whenComplete方法和exceptionally方法执行特定的Action。主要是下面的方法：

//可以处理异常，无返回值
public CompletableFuture<T> whenComplete(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action)
public CompletableFuture<T> whenCompleteAsync(BiConsumer<? super T,? super Throwable> action, Executor executor)
//可以处理异常，有返回值
public CompletableFuture<T> exceptionally(Function<Throwable,? extends T> fn)

可以看到Action的类型是BiConsumer它可以处理正常的计算结果或者异常情况。所以whenComplete 可以处理正常和异常的计算结果，exceptionally只处理异常情况。但是whenComplete只能监控是否出现了问题，不能修改返回结果，因为它没有返回值，而exceptionally有返回值，所以它可以修改返回结果。

whenComplete 和whenCompleteAsync 的区别：

• whenComplete：是执行当前任务的线程执行继续执行 whenComplete 的任务。
• whenCompleteAsync：是把whenCompleteAsync这个任务执行提交给线程池来进行执行

方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程 执行（如果是使用相同的线程池，也可能会被同一个线程选中执行)

测试代码如下：

public class ThreadTest {
    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main.............start.......");
//        CompletableFuture future = CompletableFuture.runAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 2;
//            System.out.println("当前运行结果:" + i);
//        }, executor);
        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 0;
            System.out.println("当前运行结果:" + i);
            return i;
        }, executor).whenComplete((result,exception)->{
            //虽然能得到异常信息，但是没法修改返回数据
            System.out.println("异步任务完成了...结果是"+result+";异常是"+exception);
        //可以感知异常，同时返回默认值
        }).exceptionally(throwable -> {
            return 10;
        });
        Integer integer = future.get();
        System.out.println("main.............end......."+integer);
}

handle 方法

handle 是执行任务完成时对结果的处理即可以对上一步的执行结果进行修改并且返回修改后的值。 handle 方法和 thenApply 方法处理方式基本一样。不同的是 handle 是在任务完成后再执行，还可以处理异常的任务。thenApply 只可以执行正常的任务，任务出现异常则不执行 thenApply 方法。

public <U> CompletionStage<U> handle(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn);
public <U> CompletionStage<U> handleAsync(BiFunction<? super T, Throwable, ? extends U> fn, Executor executor)

/**
* 方法执行完成后的处理
*/
CompletableFuture<Integer> future = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("当前运行结果:" + i);
            return i;
        }, executor).handle((result,exception)->{
            if (result != null){
                return result*2;
            }
            if (exception != null){
                return 0;
            }
            return 0;
        });
        Integer integer = future.get();
        System.out.println("main.............end......."+integer);
}

线程串行化

线程串行化的意思很明显就是同步执行，一个个执行，也就是前一个任务执行完毕，下一个任务才可以执行，哪怕方法带有ASync也是这样的，Async只能保证下一个任务会交给线程池去异步处理，而不是由上一个任务的线程接着执行下一个任务。

• thenApply 方法：当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。

• thenApplyAsync：能接受上一步结果，有返回值

• thenAccept 方法：消费处理结果。接收任务的处理结果，并消费处理，无返回结果。

• thenAcceptAsync：能接受上一步结果，但是无返回值

• thenRun 方法：只要前面的任务执行完成，就开始执行thenRun，但它不能获取上一步的执行结果

  带有 Async 默认是异步执行的（即任务交给线程池处理），同之前，以上方法执行都要前置任务成功完成。

  Function

  T：上一个任务返回结果的类型

  U：当前任务的返回值类型

Tips：从这里开始以及下面的所有run，accept，apply方法都有相同的特性：

• thenRun 方法：
  只要上面的任务执行完成，就开始执行 thenRun，不接收上一步结果，且无返回值。
• thenAccept 方法：
  消费处理结果。接收任务的处理结果，并消费处理，无返回结果。
• thenApply 方法：
  当一个线程依赖另一个线程时，获取上一个任务返回的结果，并返回当前任务的返回值。

- /**
           * 线程串行化
           * 1）、thenRun 不能获取得到上一步的执行结果
           */
  //        CompletableFuture thenRunAsync = CompletableFuture.supplyAsync(() -> {
  //            System.out.println("当前线程：" + Thread.currentThread().getId());
  //            int i = 10 / 5;
  //            System.out.println("当前运行结果:" + i);
  //            return i;
  //        }, executor).thenRunAsync(() -> {
  //            System.out.println("任务2启动了。。。。");
  //        }, executor);

        /**
         * 线程串行化
         * 1）、thenRun 不能获取得到上一步的执行结果,无返回值
         * 2)、thenAcceptAsync能接收上一步返回结果，但无返回值
         */

//        CompletableFuture thenRunAsync = CompletableFuture.supplyAsync(() -> {
//            System.out.println("当前线程：" + Thread.currentThread().getId());
//            int i = 10 / 5;
//            System.out.println("当前运行结果:" + i);
//            return i;
//        }, executor).thenAcceptAsync(res -> {
//            System.out.println("任务2启动了。。。。"+res);
//        }, executor);
    
        /**
         * 线程串行化
         * 1）、thenRun 不能获取得到上一步的执行结果,无返回值
         * 2)、thenAcceptAsync能接收上一步返回结果，但无返回值
         * 3)、thenApplyAsync能接收上一步的返回结果，也有返回值
         */
        CompletableFuture<String> thenApplyAsync = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("当前运行结果:" + i);
            return i;
        }, executor).thenApplyAsync(res -> {
            System.out.println("任务2启动了。。。。" + res);
            return "hello" + res;
        }, executor);
     
        System.out.println("main.............end......."+ thenApplyAsync.get());
    }

两任务组合-都要完成

• runAfterBoth

两个CompletionStage（顶级接口，也是CompletableFuture的父接口），两个任务都执行完毕才会执行下一步的操作（Runnable），这个方法不能获取前两个任务执行的结果，只需两个future 处理完任务后， 就会自动处理该任务。

这里说明一下两个组合任务，一个是方法的调用者一个是参数other，action是第三个要执行的任务。

public CompletionStage<Void> runAfterBoth(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterBothAsync(CompletionStage<?> other,Runnable action,Executor)

• thenAcceptBoth

当两个CompletionStage都执行完成后，把结果一块交给thenAcceptBoth进行处理。这个方法组合两个 future，可以获取两个 future 任务的返回结果（泛型T和U），然后处理任务，没有返回值。

public <U> CompletionStage<Void> thenAcceptBoth(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action);
public <U> CompletionStage<Void> thenAcceptBothAsync(CompletionStage<? extends U> other,BiConsumer<? super T, ? super U> action,     Executor executor);

• thenCombine

thenCombine 会把两个 CompletionStage 的任务都执行完成后，把两个任务的结果一块交给 thenCombine 来处理。它组合两个 future，获取两个 future 的返回结果，并返回当前任务的返回值

public <U,V> CompletionStage<V> thenCombine(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn);
public <U,V> CompletionStage<V> thenCombineAsync(CompletionStage<? extends U> other,BiFunction<? super T,? super U,? extends V> fn,Executor executor);

  /**
         * 不能得到两个任务的参数，也无返回结果
         */
//        future01.runAfterBothAsync(future02,()->{
//            System.out.println("任务三开始。。。");
//        },executor);
        /**
         * 能得到两个任务的参数，无返回结果
         */
//        future01.thenAcceptBothAsync(future02,(f1,f2)->{
//            System.out.println("任务三开始。。。之前的结果"+f1+":"+f2);
//        },executor);

        /**
         * 能得到两个任务的参数，无返回结果
         */
		CompletableFuture<String> thenCombineAsync = future01.thenCombineAsync(future02, (f1, f2) -> {
            System.out.println("任务三开始。。。之前的结果" + f1 + ":" + f2);
            return f1 + ":" + f2 + "->haha";
        }, executor);
        System.out.println("main.............end......." + thenCombineAsync.get());
}

两任务组合-只要有一个任务完成就执行接下来的任务

• runAfterEither 方法：run开头的不接收上一步的结果，自己也无返回值

两个CompletionStage，任何一个完成了都会执行下一步的操作（Runnable）

public CompletionStage<Void> runAfterEither(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action);
public CompletionStage<Void> runAfterEitherAsync(CompletionStage<?> other,Runnable action,Executor executor);

• acceptEither 方法

两个CompletionStage，谁执行返回的结果快，action就用那个CompletionStage的结果进行下一步的处理操作。即两个任务有一个执行完成，获取它的返回值，执行新任务，没有新的返回值。

public CompletionStage<Void> acceptEither(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? super T> action);
public CompletionStage<Void> acceptEitherAsync(CompletionStage<? extends T> other,Consumer<? supe

• applyToEither 方法：accept和apply两个开头的需要获取上一步的结果，但accept只接受无返回值，apply有返回值

两个CompletionStage，谁执行返回的结果快，我就用那个CompletionStage的结果进行下一步的转化操作。

public <U> CompletionStage<U> applyToEither(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? super T, U> fn);
public <U> CompletionStage<U> applyToEitherAsync(CompletionStage<? extends T> other,Function<? sup

   CompletableFuture<Object> future01 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务1线程：" + Thread.currentThread().getId());
            int i = 10 / 5;
            System.out.println("任务1线程结束");
            return i;
        }, executor);
        CompletableFuture<Object> future02 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2线程：" + Thread.currentThread().getId());
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2线程结束");
            return "hello";
        }, executor);

• thenCompose 方法

thenCompose 方法允许你对两个 CompletionStage 进行流水线操作，第一个操作完成时，将其结果作为参数传递给第二个操作。

public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn);
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage<U>> fn) ;
public <U> CompletableFuture<U> thenComposeAsync(Function<? super T, ? extends CompletionStage

多任务组合

public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)

• allOf：等待所有任务完成之后才会执行后面的任务

CompletableFuture<String> futureAttr = CompletableFuture.supplyAsync(() -> {
              System.out.println("查询商品的属性");
              return "黑色+256g";
          },executor);

        CompletableFuture<String> futureImg = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(3000);
                System.out.println("查询商品的图片信息");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return "hello.jpg";
        },executor);
     
        CompletableFuture<String> futureDesc = CompletableFuture.supplyAsync(() -> {
            System.out.println("查询商品的介绍");
            return "华为";
        },executor);
        CompletableFuture<Void> allOf = CompletableFuture.allOf(futureAttr, futureImg, futureDesc);
        allOf.get();//等待所有线程执行完
        System.out.println("main.............end......."+futureAttr.get()+"=>"+futureImg.get()+"=>"+futureDesc.get() );
    }

public static CompletableFuture