【Future的概念：
interface Future<V> ，表示异步计算的结果，Future有个get方法而获取结果只有在计算完成时获取，否则会一直阻塞直到任务转入完成状态，然后会返回结果或者抛出异常。
相对于继承Thread来创建线程方式，使用Runnable可以让你的实现类同时实现多个接口，而相对于Callable及Future，Runnable方法并不返回任务执行结果且不能抛出异常。
【interface Future<V> 具有如下方法：
public interface Future<V> {
//取消计算，如果尚未开始，直接取消不再运算，如果正在进行：mayInterruptIfRunning等于true就会被中断。
//注意一点：只要调用了cancle()，无论任务是否能够执行，再调用get()都会出现cancledException,这是由于
//Future.state的状态被置为CANCELLED = 4，所致的;
boolean cancel(boolean mayInterruptIfRunning)
//判断计算是否取消。
boolean isCancelled();
//判断计算是否完成，如果计算完成返回true，否则返回false
boolean isDone();
//获得异步计算的结果，如果在调用get()的时候结果还没有计算出来，调用线程将被阻塞。
V get() throws InterruptedException, ExecutionException;
//获得异步计算的结果，如果在调用get()的时候结果还没有计算出来，调用线程将被阻塞。如果调用超时将会抛出TimeoutException。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
补充：
FutureTask：包装器，可以将Callable转换成为Future与Runnable,它同时实现了二者的接口。
Callable:可以为异步方法返回计算结果。
【下面我们实现一种基于Future的场景
public class Exercise {
private SimpleApplicationService simpleApplicationService = new SimpleApplicationService();
@Test
public void futureTest() throws InterruptedException, ExecutionException {
long st = System.currentTimeMillis();
//这里本是一callable接口实现，我用lambda方便一点
FutureTask result = new FutureTask<String>(() -> simpleApplicationService.query());
//记住我们的任务都与需要开启一个新的线程
Thread t = new Thread(result);
t.start();
long end = System.currentTimeMillis();
System.out.println("耗时：" + (end - st) + " 结果：" + result.get());
}
}
public class SimpleApplicationService {
public String query() throws InterruptedException {
System.out.println("开始查询");
Thread.sleep(2000);
return "query result";
}
}
【反思一些问题:
1.每个异步方法都需要新开启一个线程这样很消耗资源。
2.每次都要new一个thread挺麻烦的。
【解决方案：
使用线程池：
1.构建一个新的线程是有代价的，因为设计到与操作系统的交互。如果程序中创建了大量的并且生命周期很短的线程，我们应该使用线程池。
一个线程池包含很多准备运行的空闲线程，每当run()执行完毕后，线程不会死亡而是回到线程池准备为下一个请求提供服务。
2.另一个使用线程池的理由是减少并发线程数。创建大量线程会大大降低性能甚至拖垮虚拟机。
【Executor：
Executors类有许多静态方法可创建线程池。例如：
Executors.newCachedThreadPool():对于一个任务，有空闲线程可用则会立即执行，否则创建一个新的线程。空闲线程存活60s。
Executors.newFixedThreadPool(n):构建具有固定大小的线程池，若任务多余空闲线程数，则将多余任务放置等待队列中。
Executors.newSingleThreadExecutor()：只有一个空闲线程的线程池，任务执行一个接一个;
以上三个方法返回ExecutorService接口的ThreadPoolExecutor对象。
核心(简介)：
ThreadPoolExecutor
public class ThreadPoolExecutor extends AbstractExecutorService {
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory);
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,RejectedExecutionHandler handler);
//事实上，前面三个构造器都是调用的第四个构造器进行的初始化工作。
public ThreadPoolExecutor(int corePoolSize,int maximumPoolSize,long keepAliveTime,TimeUnit unit,
BlockingQueue<Runnable> workQueue,ThreadFactory threadFactory,RejectedExecutionHandler handler);
}
参数含义：
corePoolSize：核心池的大小，这个参数跟后面讲述的线程池的实现原理有非常大的关系。
在创建了线程池后，默认情况下，线程池中并没有任何线程，而是等待有任务到来才创建线程去执行任务，除非调用了prestartAllCoreThreads()或者prestartCoreThread()方法。
从这2个方法的名字就可以看出，是预创建线程的意思，即在没有任务到来之前就创建corePoolSize个线程或者一个线程。默认情况下，在创建了线程池后，线程池中的线程数为0。
当有任务来之后，就会创建一个线程去执行任务，当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
maximumPoolSize：线程池最大线程数，这个参数也是一个非常重要的参数，它表示在线程池中最多能创建多少个线程；
keepAliveTime：表示线程没有任务执行时最多保持多久时间会终止。默认情况下，只有当线程池中的线程数大于corePoolSize时，keepAliveTime才会起作用。
直到线程池中的线程数不大于corePoolSize，即当线程池中的线程数大于corePoolSize时，如果一个线程空闲的时间达到keepAliveTime，则会终止，直到线程池中的线程数不超过corePoolSize。
但是如果调用了allowCoreThreadTimeOut(boolean)方法，在线程池中的线程数不大于corePoolSize时，keepAliveTime参数也会起作用，直到线程池中的线程数为0；
unit：参数keepAliveTime的时间单位
workQueue：一个阻塞队列，用来存储等待执行的任务，这个参数的选择也很重要，会对线程池的运行过程产生重大影响，一般来说，这里的阻塞队列有以下几种选择：
ArrayBlockingQueue;LinkedBlockingQueue;SynchronousQueue;
threadFactory：线程工厂，主要用来创建线程；
handler：表示当拒绝处理任务时的策略，有以下四种取值：
ThreadPoolExecutor.AbortPolicy:丢弃任务并抛出RejectedExecutionException异常。
ThreadPoolExecutor.DiscardPolicy：也是丢弃任务，但是不抛出异常。
ThreadPoolExecutor.DiscardOldestPolicy：丢弃队列最前面的任务，然后重新尝试执行任务（重复此过程）
ThreadPoolExecutor.CallerRunsPolicy：由调用线程处理该任务
使用连接池应该做的事：
1.调用Executors的静态方法创建线程池。
2.调用submit(),提交一个Callable对象或者Runnable对象。
3.保存好获得的Future<>对象，其中是计算结果(如果提交的是Callable)。
4.没有任何任务再提交的时候使用shutDown().
public class TaskExercise {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//future + callable
ExecutorService executor = Executors.newCachedThreadPool();
CallTask callTask = new CallTask();
Future<String> taskReturn = executor.submit(callTask);
System.out.println(taskReturn.get());
//futureTask
FutureTask<String> futureTask = new FutureTask<String>(callTask);
executor.submit(futureTask);
System.out.println(futureTask.get());
//runable
Runnable runTask = new RunTask();
String result = "xz";
Future<?> runTaskReturn = executor.submit(runTask,result);
System.out.println(runTaskReturn.get());
executor.shutdown();
}
}
class CallTask implements Callable<String>{
@Override
public String call() throws Exception {
return "task return";
}
}
class RunTask implements Runnable{
@Override
public void run() {
System.out.println("run");
}
}
【控制任务组：
有时使用执行器更有意义的场景是控制一组相关任务。
1.shutdownNow():取消所有任务
2.invokeAny():提交所有对象到一个Callable对象集合，并返回某个已完成的任务结果。例如：如果你愿意接受任何一种解决方案的话。
还有其他一些方法等我们真正用到时再学习好了~
【补充：
spring中实现异步调用：spring为任务调度与异步方法执行提供了注解支持。通过在方法上设置@Async注解，可使得方法被异步调用。
也就是说调用者会在调用时立即返回，而被调用方法的实际执行是交给Spring的TaskExecutor来完成。如果是有返回值的话记得：
接口返回Future<>,实现返回AsyncResult<>。
