Futrure模式

Future模式概述

Future模式是一种常见的设计模式，它的核心思想是异步调用，当调用一个函数方法时，如果方法执行非常慢，但我们又不急着需要结果，因此我们可以让被调用者立即返回，让他在后台慢慢处理，对于调用者来说可以先处理一些其他的任务，当真正需要数据时尝试获得需要的数据。
Future模式无法立即给出需要的数据，但是他会返回一个契约，将来凭借着这个锲约去重新获取结果。

ExecutorService提供的方法

<T> Future<T> submit(Callable<T> task);  <T> Future<T> submit(Runnable task, T result);  Future<?> submit(Runnable task);  

第一个方法：submit提交一个实现Callable接口的任务，并且返回封装了异步计算结果的Future。
第二个方法：submit提交一个实现Runnable接口的任务，并且指定了在调用Future的get方法时返回的result对象。
第三个方法：submit提交一个实现Runnable接口的任务，并且返回封装了异步计算结果的Future。

Callable

Callable接口类似于Runnable，从名字就可以看出来了，但是Runnable不会返回结果，并且无法抛出返回结果的异常，而Callable功能更强大一些，被线程执行后，可以返回值，这个返回值可以被Future拿到，也就是说，Future可以拿到异步执行任务的返回值
Callable位于java.util.concurrent包下，它是一个接口，它里面只有一个方法：

public interface Callable<V> {    /**     * Computes a result, or throws an exception if unable to do so.     *     * @return computed result     * @throws Exception if unable to compute a result     */    V call() throws Exception;}

这是一个泛型接口，call函数返回的类型就是传进来的类型。

Future

Future就是对于具体的Runnable或者Callable任务的执行结果进行取消、查询是否完成、获取结果。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

Future类位于java.util.concurrent包下，它是一个接口：

public interface Future<V> {    boolean cancel(boolean mayInterruptIfRunning);    boolean isCancelled();    boolean isDone();    V get() throws InterruptedException, ExecutionException;    V get(long timeout, TimeUnit unit)        throws InterruptedException, ExecutionException, TimeoutException;}

常用的方法为：
V get() ：获取异步执行的结果，如果没有结果可用，此方法会阻塞直到异步计算完成。
V get(Long timeout , TimeUnit unit) ：获取异步执行结果，如果没有结果可用，此方法会阻塞，但是会有时间限制，如果阻塞时间超过设定的timeout时间，该方法将抛出异常。
boolean isDone() ：如果任务执行结束，无论是正常结束或是中途取消还是发生异常，都返回true。
boolean isCanceller() ：如果任务完成前被取消，则返回true。
boolean cancel(boolean mayInterruptRunning) ：如果任务还没开始，执行cancel(…)方法将返回false；如果任务已经启动，执行cancel(true)方法将以中断执行此任务线程的方式来试图停止任务，如果停止成功，返回true；当任务已经启动，执行cancel(false)方法将不会对正在执行的任务线程产生影响(让线程正常执行到完成)，此时返回false；当任务已经完成，执行cancel(…)方法将返回false。mayInterruptRunning参数表示是否中断执行中的线程。
总结Futrue的功能：
1.判断任务能否完成
2.能够中断任务
3.能够获取任务执行结果

FutrueTask

public class FutureTask<V> implements RunnableFuture<V>

然而RunnableFuture接口为

public interface RunnableFuture<V> extends Runnable, Future<V> {void run();}

FutureTask提供了2个构造器：

public FutureTask(Callable<V> callable) {}public FutureTask(Runnable runnable, V result) {}

FutureTask除了实现了Future接口外还实现了Runnable接口，因此FutureTask也可以直接提交给Executor执行，当然也可以调用线程直接执行（FutureTask.run()）。接下来我们根据FutureTask.run()的执行时机来分析其所处的3种状态：
（1）未启动，FutureTask.run()方法还没有被执行之前，FutureTask处于未启动状态，当创建一个FutureTask，而且没有执行FutureTask.run()方法前，这个FutureTask也处于未启动状态。
（2）已启动，FutureTask.run()被执行的过程中，FutureTask处于已启动状态。
（3）已完成，FutureTask.run()方法执行完正常结束，或者被取消或者抛出异常而结束，FutureTask都处于完成状态。

例子1Callable+Future

import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.Future;public class Test {    public static void main(String[] args) {        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        //返回执行结果        Future<Integer> result = executor.submit( task);       // executor.shutdown();        System.out.println("主线程在执行任务");        try {            System.out.println("task运行结果"+result.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }        System.out.println("所有任务执行完毕");    }}class Task implements Callable<Integer>{    @Override    public Integer call() throws Exception {        System.out.println("子线程在进行计算");        Thread.sleep(3000);        int sum = 0;        for(int i=0;i<100;i++)            sum += i;        return sum;    }}

例子2Callable+FutrueTask

import java.util.concurrent.Callable;import java.util.concurrent.ExecutionException;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.FutureTask;public class Test {    public static void main(String[] args) {        //第一种方式        ExecutorService executor = Executors.newCachedThreadPool();        Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        executor.submit(futureTask);        executor.shutdown();        //第二种方式，注意这种方式和第一种方式效果是类似的，只不过一个使用的是ExecutorService，一个使用的是Thread        /*Task task = new Task();        FutureTask<Integer> futureTask = new FutureTask<Integer>(task);        Thread thread = new Thread(futureTask);        thread.start();*/        try {            Thread.sleep(1000);        } catch (InterruptedException e1) {            e1.printStackTrace();        }        System.out.println("主线程在执行任务");        try {            System.out.println("task运行结果"+futureTask.get());        } catch (InterruptedException e) {            e.printStackTrace();        } catch (ExecutionException e) {            e.printStackTrace();        }        System.out.println("所有任务执行完毕");    }}class Task implements Callable<Integer>{    @Override    public Integer call() throws Exception {        System.out.println("子线程在进行计算");        Thread.sleep(3000);        int sum = 0;        for(int i=0;i<100;i++)            sum += i;        return sum;    }}