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 ：供己型函数接口，没有输入参数，但是有返回结果
