在这里首先介绍下Callable和Future，我们知道通常创建线程的2种方式，一种是直接继承Thread，另外一种就是实现Runnable接口，但是这两种方式创建的线程不返回结果，而Callable是和Runnable类似的接口定义，但是通过实现Callable接口创建的线程可以有返回值，返回值类型可以任意定义。

Callable接口

1 public interface Callable<V> {
2     /**
3      * Computes a result, or throws an exception if unable to do so.
4      *
5      * @return computed result
6      * @throws Exception if unable to compute a result
7      */
8     V call() throws Exception;
9 }

可以看到，这是一个泛型接口，call()函数返回的类型就是传递进来的V类型。

那么怎么使用Callable呢？一般情况下是配合ExecutorService来使用的，在ExecutorService接口中声明了若干个submit方法的重载版本：

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

第一个submit方法里面的参数类型就是Callable。Callable一般是和ExecutorService配合来使用的，通过ExecutorService的实例submit得到Future对象。

Future

Future接口如下：

1 public interface Future<V> {
2     boolean  cancel(boolean mayInterruptIfRunning);// 试图取消对此任务的执行
3     boolean  isCancelled();      // 如果在任务正常完成前将其取消，则返回true
4     boolean  isDone();           // 如果任务已完成（不管是正常还是异常），则返回true
5     V  get() throws InterruptedException, ExecutionException; // 方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
6     // 用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null；
7     V  get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException;
8 }

Future用于表示异步计算的结果。它的实现类是FutureTask。

如果不想分支线程阻塞主线程，又想取得分支线程的执行结果，就用FutureTask

FutureTask实现了RunnableFuture接口，这个接口的定义如下：

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

可以看出RunnableFuture继承了Runnable接口和Future接口，而FutureTask实现了RunnableFuture接口。所以它既可以作为Runnable被线程执行，又可以作为Future得到Callable的返回值。

使用示例

 1 package demo.future;
 2
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.concurrent.*;
 6
 7 /**
 8  * 试验 Java 的 Future 用法
 9  */
10 public class FutureTest {
11
12     public static class Task implements Callable<String> {
13         @Override
14         public String call() throws Exception {
15             String tid = String.valueOf(Thread.currentThread().getId());
16             System.out.printf("Thread#%s : in call\n", tid);
17             return tid;
18         }
19     }
20
21     public static void main(String[] args) throws InterruptedException, ExecutionException {
22         List<Future<String>> results = new ArrayList<Future<String>>();
23         ExecutorService es = Executors.newCachedThreadPool();
24         for(int i=0; i<100;i++)
25             results.add(es.submit(new Task()));
26
27         for(Future<String> res : results)
28             System.out.println(res.get());
29     }
30
31 }

终结任务

持有Future对象，可以调用cancel()，并因此可以使用它来中断某个特定任务，如果将ture传递给cancel()，那么它就会拥有该线程上调用interrupt()以停止这个线程的权限。因此，cancel()是一种中断由Executor启动的单个线程的方式。

cancel()一般是搭配get()方法来使用的。比方说，有一种设计模式是设定特定的时间，然后去执行一个作业的线程，如果该作业能够在设定的时间内执行完毕，则直接返回结果，如果不能执行完毕，则中断作业的执行，继续执行下一个作业，在这种模式下，使用Callable和Future来实现是一个非常好的解决方案。