1. Future的使用
Future模式解决的问题是。在实际的运用场景中，可能某一个任务执行起来非常耗时，如果我们线程一直等着该任务执行完成再去执行其他的代码，就会损耗很大的性能，而Future接口就是Future的实现，它可以让当前线程将任务交给Future去执行，然后当前线程就可以去干别的事，知道耗时任务执行完成之后，当前线程直接获取结果即可。FutureTask的使用比较简单，只需要先实例化一个Callable对象，重写call方法，再创建一个FutureTask对象，将Callable对象传给FutureTask，创建一个线程，将FutureTask对象传入Thread对象，启动线程即可，接下来就直接上源码：
package com.company.thread.t5; import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask; public class FutureDemo { public static void main(String[] args) { Callable<Integer> callable = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("正在计算结果");
Thread.sleep(3000);
return 1;
}
};
FutureTask<Integer> futureTask = new FutureTask<>(callable);
Thread thread = new Thread(futureTask);
thread.start();
//做点别的
System.out.println("干点别的");
try {
System.out.println("拿到的结果为：" + futureTask.get());
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
}
2. FutureTask源码
FutureTask实现了RunnableFuture，而RunnableFuture同时继承了Runnable和Future接口，所以它既是一个任务，也实现了Future接口的功能。
从上面使用的步骤来看，我们需要先实例化一个Callable对象，所以先看看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;
}
这是一个接口，具体的实现在重写的call方法中，是需要做的任务的方法所在。
在使用方法中我们需要将Callable传给FutureTask的构造方法，所以我们先看FutureTask的构造方法：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
如果callable为空，则抛出异常，否则执行赋值操作，并将state状态改成NEW，即是初始化状态，这里说一下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;
所以初始化时state的值为0，表示当前为初始化状态。
FutureTask实现了Runnable，所以必然又run方法去供线程使用，接下来就看FutureTask重写的run()方法：
public void run() {
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
第一步判断state是否为初始化状态，不为初始化状态将将当前线程设置为FutureTask的执行线程，设置失败停止方法，经过第一步还能往下执行，则当前的state必然是初始化状态，得到Callable实例，及真正需要执行的任务代码，判断是否为空，且状态是否为初始化状态，判断成功，则执行callable的call()方法，并将执行结果赋值给result,将执行标记ran赋值为ture，执行成功时，ran为true时调用set（）方法保存结果，
set（）方法：
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
将状态从NEW偏移到COMPLETING（正在执行中），将结果保存到outcome中，（outcome是一个Object类型，不止可以保存结果，还可以保存异常信息），保存完成后将偏移量改为NORMAL(正常执行完毕的状态),调用finishCompletion()方法。
finishCompletion（）方法：
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();
callable = null; // to reduce footprint
}
因为在执行过程中可能会未执行完成就调用了get方法，此时get方法会将想要获取结果的线程都等待在一个等待队列中，所以finishCompletion（）的功能就是遍历等待队列，并将等带队列中所有的有效线程唤醒（unpark）。此时等待get（）的线程将会继续执行，
当调用call方法出现异常时，result未空，ran赋值未false,调用setException()方法；
setException(Throwable t):
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
首先更改状态为COMPLETING，将异常信息保存到outcome中，更改状态为EXCEPTIONAL（表示异常执行结束），调用finishCompletion（）唤醒等待线程。run执行完成；
FutureTask还有一个重要的方法就是get()方法，用于获取Callable的call方法返回的结果或执行过程中出现的异常信息。
get()：
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
当状态小于等于COMPLETING时，表示当前任务还没有处于终止状态，即可能正在初始化或者是正在执行中，调用awaitDone()方法将线程放入等待队列，并等待起来，直到被唤醒，最后返回report（s）执行结果，
report（s：
@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
Object x = outcome;
if (s == NORMAL)
return (V)x;
if (s >= CANCELLED)
throw new CancellationException();
throw new ExecutionException((Throwable)x);
}
如果正常执行结束，返回执行结果，s >= CANCELLED表示线程不可用状态，抛出异常CancellationException，否则就是异常执行结束，抛出ExecutionException（）,这样就可以拿到执行结果。
FutureTask其核心的原理也是等待/唤醒，当调用get方法没有结果时，线程等待，当set()方法赋值成功，表示任务执行完成，有值可以返回时，唤醒等待的线程，get（）方法上等待的线程被唤醒，继续执行，最后返回结果。