Android并发二三事之Callable，Future，FutureTask

Android 并发的第二篇，本篇还是要介绍Java 方向并发相关的知识点。

主要涉及Callable与 Runnable 的关系。 Callable 如何使用， Future 概念， Future 如何使用以及 Future 的实现类 FutureTask。

最后介绍如何利用Future 实现在子线程中开启子线程去请求网络。

一、Callable :

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;

}

Callable 本身是一个泛型接口， call()方法返回的类型，就是V的类型。
可能大家更熟悉的是：

Runnable接口：

public interface Runnable {

    /**
     * Starts executing the active part of the class' code. This method is
     * called when a thread is started that has been created with a class which
     * implements {@code Runnable}.
     */
    public void run();
}

Callable 类似于Runnable 接口，用来封装一个任务，可以运行在一个线程之中。
只不过 Runnable 的 run() 方法没有返回值， 而 call() 方法具有返回值。

不过不同于 Runnable 的是，Callable 无法被封装到Thread中执行。
一般Callable 会与线程池一起使用。

在 ExecutorService 中有具有一下几个接口：

<T> Future<T> submit(Callable<T> task);


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


Future<?> submit(Runnable task);

在上一篇博客中，我们介绍了利用Executors 提供的线程池，执行联网等耗时任务：

public void request() {

        ExecutorService executor = Executors.newFixedThreadPool(5);
        executor.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    //请求网络等。
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

    }

这里其实除了execute() 方法还有一个方法可以用，那就是submit()方法。
只不过submit()方法是有返回值的,返回值就是Future 。

二、Future 接口：

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;
}

Future 可以用来获取Runnable , Callable 任务的执行结果，查询等。
一般Future 模式可以这样理解：
我有一个任务交给Future,让Future 替我去完成。在这个期间我可以做别的事情，一段时间之后，我便可以从Future 那里获取结果。
Future 一般和线程池一起使用，利用 ExecutorService 的 submit() 方法，就可以返回一个Future 对象。

Future接口提供方法来检测任务是否被执行完，等待任务执行完获得结果，也可以设置任务执行的超时时间。这个设置超时的方法就是实现Java程 序执行超时的关键。

接口的方法介绍如下：
boolean cancel (boolean mayInterruptIfRunning) 取消任务的执行。参数指定是否立即中断任务执行，或者等等任务结束

boolean isCancelled () 任务是否已经取消，任务正常完成前将其取消，则返回 true

boolean isDone () 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消，都将返回true

V get () throws InterruptedException, ExecutionException 等待任务执行结束，然后获得V类型的结果。InterruptedException 线程被中断异常， ExecutionException任务执行异常，如果任务被取消，还会抛出CancellationException

V get (long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException 同上面的get功能一样，多了设置超时时间。参数timeout指定超时时间，uint指定时间的单位，在枚举类TimeUnit中有相关的定义。如果计 算超时，将抛出TimeoutException

三、FutureTask:

FutureTask 即为Future 的实现， FutureTask 不仅实现了 Future， 还实现了 Runnable 所以其也可以作为一个Runnable 提交给线程池。

submit() 方法为我们返回的其实就是 FutureTask 对象。

四、以下为利用Future获取数据的例子：

//请求数据
public void requestCar() {

        ExecutorService executor = Executors.newFixedThreadPool(5);
        Future<ResponInfo> future = executor.submit(new Task());
        try{
            ResponInfo info = future.get();
            Log.d(TAG,"result : "+info.getName());
        }catch (Exception e){

        }

    }

//获取数据
 private ResponInfo requestInfo() {
        try {
        //模拟连接网络耗时
            Thread.sleep(3000);
        }catch (Exception e) {

        }
        return new ResponInfo("BMW", 2000);
    }

//自定义Callable
public class Task implements Callable<ResponInfo> {

        @Override
        public ResponInfo call() throws Exception {

            return requestInfo();
        }
    }

//数据实体
    public class ResponInfo {

        private String name;
        private long price;

        public ResponInfo(String name, long price) {
            this.name = name;
            this.price = price;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public long getPrice() {
            return price;
        }

        public void setPrice(long price) {
            this.price = price;
        }
    }

具体来看requestCar() 方法：

public void requestCar() {

        ExecutorService executor = Executors.newFixedThreadPool(5);
        Future<ResponInfo> future = executor.submit(new Task());
    //在这里我们可以做其他的事情。
        try{
        //调用future.get()方法后，如果结果已经返回，那么将直接返回结果。
        //如果结果还没有返回，那么当前线程将会被阻塞，以等待结果的返回。
            ResponInfo info = future.get();
            Log.d(TAG,"result : "+info.getName());
        }catch (Exception e){

        }

    }

我们还可以加入超时时间：

public void requestCar() {

        ExecutorService executor = Executors.newFixedThreadPool(5);
        Future<ResponInfo> future = executor.submit(new Task());
        try{
        //2秒内不返回，将抛出异常。
            ResponInfo info = future.get(2, TimeUnit.SECONDS);
            Log.d(TAG,"result : "+info.getName());
        }catch (Exception e){
            e.printStackTrace();
        //取消任务
            future.cancel(true);
            Log.d(TAG, "cancel ");
        }

    }

五、在第一篇中说过，如何在子线程中再开启子线程请求网络数据。

其实在子线程中请求数据不难，但是如果我们在子线程中又开启了一个线程去请求数据呢？
例如当我们需要在子线程中，利用Volley 请求数据。我们知道Volley会另外开启子线程去连接网络。

如果发生这样的情况，我们需要让当前的线程阻塞，等待数据的返回，否则根本得不到数据的。

在第四步中Future.get()方法会阻塞当前的线程等待数据的返回，刚好符合我们的需求。

OK , 这篇就介绍到这里。
下一篇会介绍如何自定义Future，实现更灵活的功能。