JUC--CompletableFuture

Future接口（FutureTask实现类）定义了操作异步任务执行一些方法，如获取异步任务的执行结果，取消任务带带执行，判断任务是否被取消，判断任务执行是否完毕等。

比如主线程让一个子线程去执行任务，子线程可能比较耗时，启动子线程开始执行任务后，主线程就去做其他事情了，忙其他事情或者先执行完，过了一会才去获取子任务的执行结果或变更任务状态。

 从上到下分别为 取消任务，获得任务的结果，按照一定时限内获得任务的结果，是否被取消，是否完成。

Futrue接口可以为主线程开一个分支任务，专门为主线程处理耗时和费力的复杂业务。

import java.util.concurrent.Callable;

public class Test3 {
    public static void main(String[] args) {

    }

}
//无返回值
class MyThread1 implements Runnable{

    @Override
    public void run() {

    }
}

//有返回值，会抛异常
class MyThread2 implements Callable<String>{

    @Override
    public String call() throws Exception {
        return null;
    }
}

要获得一个多线程，Thread的构造方法只能传一个Runnable对象，但是这个方法没有返回值，直接找一个Runnable的实现类，可以看到

 看看这个里面的实现类

 这个类里面有这样一个构造方法，通过构造注入

 这就把runnable,future,callable都关联上了。这也就是我们用FutureTask的原因

目的：异步多线程任务执行且返回有结果，三个特点：多线程/有返回/异步任务

import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

public class Test3 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<>(()->{
            System.out.println("我是子线程");
            return "hello";
        });
        Thread thread = new Thread(futureTask,"t1");
        thread.start();
        System.out.println("子线程的返回值"+futureTask.get());
    }

}

future的优点 ：future+线程池异步多线程任务配合，能显著提高程序的执行效率。

import java.util.concurrent.*;

public class Test3 {
    public static void main(String[] args){
        long startTime = System.currentTimeMillis();
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        FutureTask<String> futureTask1 = new FutureTask<String>(()->{
            try { TimeUnit.SECONDS.sleep(2); } catch (InterruptedException e) {e.printStackTrace();}
            return "task1 over";
        });
        executorService.submit(futureTask1);
        FutureTask<String> futureTask2 = new FutureTask<String>(()->{
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) {e.printStackTrace();}
            return "task2 over";
        });
        executorService.submit(futureTask2);
        try { TimeUnit.SECONDS.sleep(5); } catch (InterruptedException e) {e.printStackTrace();}
        long endTime = System.currentTimeMillis();
        System.out.println("消耗时长:"+(endTime - startTime) + " 毫秒 ");
        executorService.shutdown();
    }

}

 本来三个线程依次执行就是10秒左右，这个时候异步多线程就只需要5秒，显著提升了运行效率。

缺点：

1.get（）阻塞，需要等待结果，建议放在程序的后面执行

 

2.isDone（）轮询的方法会耗费无谓的CPU资源，而且也不见得能及时地得到计算结果。

如果想要异步获取结果，通常都会以轮询的方式去获取结果尽量不要阻塞。

结果：future对于结果的获取不是很友好

回调通知：应对Future的完成时间，完成可可以告诉我，也就是我们的回调通知

通过轮询的方式去判断任务是否完成这样非常占用CPU资源。

创建异步任务：Future + 线程池

这个时候就引入了CompletableFuture

CompletableFuture提供了一种观察者模式类似的机制，可以让任务执行完成后通知监听的一方。

可以看到 CompletableFuture接口实现了这两个接口，Future我们已经看过了，CompletionStage是什么，它代表异步计算过程中的某一个阶段，一个阶段完成以后可能会触发另外一个阶段。

一个阶段的计算执行可以是一个Function，Consumer或者Runnable。

一个阶段的执行可能是被单个阶段的完成触发，也可能是由多个阶段一起触发。

有些类似于Linux系统的管道分隔符传参数。

官方不建议直接new一个空参CompletableFuture对象

有4个核心的静态方法，来创建一个异步任务：

runAsync：无返回值

supplyAsync：有返回值

指定线程池用指定的，没有指定用ForkJoinPool（）

supplier 供己型，没有输入参数，但是有返回结果

CompletableFuture通用：它是Future的功能增强版，减少阻塞和轮询，可以传入回调对象，当异步任务完成或者发生异常时，自动调用回调对象的回调方法。

默认的线程池是守护线程，主线程关闭也会跟着关闭。

自定义线程池，需要手动关闭。

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

public class Test4 {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(3);
        try {
            CompletableFuture.supplyAsync(()->{
                return "a";
            },executorService).whenComplete((v,e) -> {
                //回调，怎么都会进
                if (e == null){
                    System.out.println("成功");
                }
            }).exceptionally( e -> {
                return null;
            });
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            executorService.shutdown();
        }

    }
}

CompletableFuture优点：

1.异步任务结束时，会自动调用某个对象的方法；

2.主线程设置好回调后，不再关心异步任务的执行，异步任务之间可以顺序执行。

3.异步任务出错时，会自动回调某个对象的方法。

函数式编程：

Runnable:无参，无返回值

Function：功能性函数，有一个输入参数，一个返回参数

Consumer：消费型函数接口，有一个输入参数，无返回值（BiConsumer：有两个输入参数）

supplier ：供己型函数接口，没有输入参数，但是有返回结果

 对计算速度进行选用

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        CompletableFuture<String> a = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) {e.printStackTrace();}
            return "a";
        });
        CompletableFuture<String> b = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) {e.printStackTrace();}
            return "b";
        });
        //谁快用谁
        CompletableFuture<String> result = a.applyToEither(b, f -> {
            return f;
        });
        System.out.println(result.join());

    }
}

对计算结果进行合并

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;

public class Test4 {
    public static void main(String[] args) {
        CompletableFuture<Integer> a = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(4); } catch (InterruptedException e) {e.printStackTrace();}
            return 10;
        });
        CompletableFuture<Integer> b = CompletableFuture.supplyAsync(() -> {
            try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) {e.printStackTrace();}
            return 20;
        });
        //等待俩者结果一起返回
        CompletableFuture<Integer> result = a.thenCombine(b, (x,y) -> {
            return x + y;
        });
        System.out.println(result.join());

    }
}