JAVA CompletableFuture（异步多线程）真香

大家好，我是囧叔。欢迎来到小型吹逼现场，如观点请有误请直接喷不需要走流程，拱手作揖。

什么是 快乐星球 Future ？

Future是java 5引入的一个interface，可以方便的用于异步结果的获取。

(PS:了解新特性出现的版本就像玩王者需要了解新版本哪个英雄增强哪个英雄削弱，有助于串起我们的记忆链条，以及遇到问题对症下药。出现在java5那肯定是之前的使用方法有缺陷或者他因，各位看官自行百度哈，欢迎评论水一波哈哈）

Future在Java5就引入了：

优点：一定程度上让一个线程池内的任务异步执行了
缺点：传统回调最大的问题就是不能将控制流分离到不同的事件处理器中。例如主线程等待各个异步执行的线程返回的结果来做下一步操作，则必须阻塞在future.get()的地方等待结果返回。这时候又变成同步了。

CompletableFuture在Java8引入：

实现了Future和CompletionStage接口，保留了Future的优点，并且弥补了其不足。即异步的任务完成后，需要用其结果继续操作时，无需等待。可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。
可见，这种方式才是我们需要的异步处理。一个控制流的多个异步事件处理能无缝的连接在一起。

举个项目中的小例子

背景：某项目A中，在性能优化过程中，发现某接口耗时过长，正常接口耗时一般150ms算正常（当然也视公司、项目而定），经分析发现是接口中有一个for循环用了一个反射去调用不同的业务实现类，实现类里面会涉及到查库，导致整体耗时较长，下面以一个小栗子模拟上面的场景：

package com.example.demo.java8;

import java.io.Console;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class CompletableFutureDemo {


    public static void main(String[] args) {
        long testStartTime = System.currentTimeMillis();
        test();
        long testEndTime = System.currentTimeMillis();
        System.out.println("test cost time :"+ (testEndTime-testStartTime));


        long asynTestStartTime = System.currentTimeMillis();
        asyncTest();
        long asynTestEndTime = System.currentTimeMillis();
        System.out.println("asynTest cost time :"+ (asynTestEndTime-asynTestStartTime));
        /*Console
        test cost time :5037
        asynTest cost time :1050*/

    }

    public static List<Integer> test(){
        List<Integer> testList = new ArrayList<>();
        for(int i = 0;i < 5;i ++){
            try {
                testList.add(i);
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return testList;
    }

    public static void asyncTest(){
        List<Integer> asynTestList = new ArrayList<>();
        List<CompletableFuture<Integer>> futures = new ArrayList<>();
        for(int i = 0;i < 5;i ++){
            int finalI = i;
            futures.add(CompletableFuture.supplyAsync(()->{
                int temp = finalI;
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e)  {
                    e.printStackTrace();
                }
                return temp;
            }));
        }
        for(Future<Integer> f:futures){
            try {
                Integer temp = f.get();
                asynTestList.add(temp);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (ExecutionException e) {
                e.printStackTrace();
            }
        }
    }

}

执行结果：

test cost time :5037

asynTest cost time :1050

 很直观的，用了异步的耗时是原来1/5，性能有显著提升。Future代表的是异步执行的结果，当异步执行结束之后，返回的结果将会保存在Future中，可以对future继续进行业务上的数据处理。