一、Future

Future是一个接口，所有方法如下：

上源码：

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

• cancel：取消任务（mayInterruptIfRunning是否中断正在执行的任务）。
• isCancelled：任务是否取消
• isDone：任务是否执行完成。
• get：获取任务结果
• get(long timeout, TimeUnit unit)：有等待时间的获取任务结果。

二、FutureTask

FutureTask是一个类，实现了RunnableFuture接口，RunnableFuture接口继承了Runnable和Future，关系图如下：

FutureTask有两个构造函数：

public FutureTask(Callable<V> callable) {
    if (callable == null)
        throw new NullPointerException();
    this.callable = callable;
    this.state = NEW;       // ensure visibility of callable
}

public FutureTask(Runnable runnable, V result) {
    this.callable = Executors.callable(runnable, result);
    this.state = NEW;       // ensure visibility of callable
}

第一个构造函数传入一个Callable对象，第二个构造函数传入Runnable对象和一个V类型的对象，然后在函数中将这两个参数构造成一个Callable对象。可见FutureTask和Future的核心就是要执行Callable并获取返回结果。

FutureTask中的几种状态：

/**
 *
 * 可能的状态转换：
 * NEW -> COMPLETING -> NORMAL
 * NEW -> COMPLETING -> EXCEPTIONAL
 * NEW -> CANCELLED
 * NEW -> INTERRUPTING -> INTERRUPTED
 */
private volatile int state;
private static final int NEW          = 0;
private static final int COMPLETING   = 1;
private static final int NORMAL       = 2;
private static final int EXCEPTIONAL  = 3;
private static final int CANCELLED    = 4;
private static final int INTERRUPTING = 5;
private static final int INTERRUPTED  = 6;

查看源码，发现状态共有七种，初始化为NEW,运行时仅在set、setException和cancel方法中会转换为终端状态。终端状态共四种：NORMAL结果正常、EXCEPTIONAL结果异常、CANCELLED任务取消、INTERRUPTED任务中断，可能的状态转换源码中注释已写清楚。

三、示例

Future在线程池中主要做为一个返回（submit方法），用于接收执行完成的结果，FutureTask则是具体实现。
测试代码：

public class ExecutorTest1 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        ExecutorTest1 test1 = new ExecutorTest1();
        Future<String> futureTest = executorService.submit(() -> test1.say("测试返回值"));
        executorService.shutdown();
    }

    public String say(String a){
        System.out.println("执行了say方法");
        return "test"+a;
    }

}

以上代码，执行了say方法，获取到了futureTest对象，但是futureTest对象不能直接使用，需要调用get方法获取结果，以上代码执行结果：

获取Future对象结果代码示例：

public class ExecutorTest1 {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        ExecutorTest1 test1 = new ExecutorTest1();
        Future<String> futureTest = executorService.submit(() -> test1.say("测试返回值"));
        try {
            String s = futureTest.get();
            System.out.println(s);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        executorService.shutdown();
    }

    public String say(String a){
        System.out.println("执行了say方法");
        return "test"+a;
    }

}

可见要执行有返回值的线程，需要用Future来接收。那么FutureTask在哪里使用了呢，在执行方法的时候将传入的Callable对象或者Runnable对象封装成FutureTask对象，源码如下：

public Future<?> submit(Runnable task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<Void> ftask = newTaskFor(task, null);
    execute(ftask);
    return ftask;
}

public <T> Future<T> submit(Runnable task, T result) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task, result);
    execute(ftask);
    return ftask;
}

public <T> Future<T> submit(Callable<T> task) {
    if (task == null) throw new NullPointerException();
    RunnableFuture<T> ftask = newTaskFor(task);
    execute(ftask);
    return ftask;
}

newTaskFor方法如下：

protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
    return new FutureTask<T>(runnable, value);
}

四、结果

Future和FutureTask的核心作用是获取有返回值的线程结果。

Java多线程：Future和FutureTask

Java线程池详解