起源
我们创建线程，如果想获取线程运行完的结果，一般是使用回调的方式。
例如：
package com.test;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Test {
public static void main(String[] args) {
final MyCall myCall = new MyCall() {
@Override
public void call(int num) {
System.out.println("获取到的结果值为" + num);
}
};
ExecutorService pool = Executors.newFixedThreadPool(1);
pool.execute(new Runnable() {
@Override
public void run() {
System.out.println("线程"+Thread.currentThread().getName()+" 开始");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
myCall.call(100);
System.out.println("线程"+Thread.currentThread().getName()+" 结束");
}
});
}
}
interface MyCall{
public void call(int num);
}
结果如图：
这种方式有三个缺点：
- 1.必须要创建回调接口。而且线程运行中可能产生异常，那么回调接口至少包含成功回调和错误回调两个方法。
- 2.当线程运行后，只能等到线程回调接口，本身我们没有办法进行取消操作。
- 3.如果要重复获取同样线程运行结果的值，还是只能重新运行线程。当然你也可以使用一个变量缓存结果值。
而java中的Future和Callable模式，对这种方式提供了优化。
Future和Callable
我们用回调的原因是，因为结果由另一个线程计算，当前线程无需等待，所以将回调接口传给计算线程。当计算完成时，调用这个接口，回传结果值。
而另一种方式就是当前线程去获取值的时候，如果计算结果的线程还没有计算完毕，那么当前线程就等待，直到计算完毕，会唤醒等待结果的线程。如果已经计算完毕了，就直接获取结果值。
我们来看一下Future和Callable接口
1.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;
}
相当于Runnable的run方法，一般都是耗时操作，但是不一样的是，这个方法会返回结果值
Future
要想解决我们上面说的三个缺点，那么Future接口至少有两个方法：
- get()方法：获取结果值，如果当前Future还没有结束，那么当前线程就等待，直到Future运行结束，那么会唤醒等待结果值的线程的。
- cancel()方法：取消当前的Future。会唤醒所有等待结果值的线程。
public interface Future<V> {
/**
* 取消当前的Future。会唤醒所有等待结果值的线程，抛出CancellationException异常
* @param mayInterruptIfRunning 是否中断 计算结果值的那个线程
* @return 返回true表示取消成功
*/
boolean cancel(boolean mayInterruptIfRunning);
// 当前的Future是否被取消，返回true表示已取消。
boolean isCancelled();
// 当前Future是否已结束。包括运行完成、抛出异常以及取消，都表示当前Future已结束
boolean isDone();
// 获取Future的结果值。如果当前Future还没有结束，那么当前线程就等待，
// 直到Future运行结束，那么会唤醒等待结果值的线程的。
V get() throws InterruptedException, ExecutionException;
// 获取Future的结果值。与get()相比较多了允许设置超时时间。
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
可以看出Callable代表任务，Future代表结果值。他们的结合体就是FutureTask类。
FutureTask
FutureTask实现了RunnableFuture接口，RunnableFuture接口继承了Callable和Future：
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
FutureTask的状态
FutureTask总共有6状态，在源码中表示如下：
// 表示FutureTask当前的状态
private volatile int state;
// NEW 新建状态，表示这个FutureTask还没有开始运行
private static final int NEW = 0;
// COMPLETING 完成状态， 表示FutureTask任务已经计算完毕了，
// 但是还有一些后续操作，例如唤醒等待线程操作，还没有完成。
private static final int COMPLETING = 1;
// FutureTask任务完结，正常完成，没有发生异常
private static final int NORMAL = 2;
// FutureTask任务完结，因为发生异常。
private static final int EXCEPTIONAL = 3;
// FutureTask任务完结，因为取消任务
private static final int CANCELLED = 4;
// FutureTask任务完结，也是取消任务，不过发起了中断运行任务线程的中断请求。
private static final int INTERRUPTING = 5;
// FutureTask任务完结，也是取消任务，已经完成了中断运行任务线程的中断请求。
private static final int INTERRUPTED = 6;
这六种状态分为四类：
- 1.NEW状态：这个FutureTask任务还没有做任何操作，只有这个状态下的任务，我们可以调用run方法运行任务，或者调用cancel方法取消任务。
- 2.COMPLETING状态：表示run方法运行完成，但是还有一些后序操作没有执行，比如唤醒正在等待任务结果的线程。切记这个状态FutureTask任务没有完结，不能返回结果值。
- 3.NORMAL和EXCEPTIONAL状态：任务完结，可能是正常完结也可能是异常完结。
- 4.CANCELLED、INTERRUPTING和INTERRUPTED状态：取消任务，任务也是完结。区别就是CANCELLED只是改变状态，而INTERRUPTING不仅改变状态，还会对正在运行FutureTask任务的线程进行中断。INTERRUPTED表示已经调用了中断请求。
get()方法获取结果值
因为FutureTask任务一般运行在一个线程中，其它线程来获取任务的结果值应该遵循以下原则：
- 1.如果FutureTask任务已经完结，那么应该返回结果值。
- 2.如果FutureTask任务没有完结，那么当前线程就应该等待，直到任务运行完结，会唤醒这个等待结果的线程，返回结果值。
源码如下：
public V get() throws InterruptedException, ExecutionException {
int s = state;
/**
* 状态小于等于COMPLETING，表示FutureTask任务还没有完结，
* 所以调用awaitDone方法，让当前线程等待
*/
if (s <= COMPLETING)
s = awaitDone(false, 0L);
// 返回结果值或者抛出异常
return report(s);
}
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
/**
* 状态小于等于COMPLETING，表示FutureTask任务还没有完结，
* 所以调用awaitDone方法可以将当前线程插入等待结果的线程队列中去，
* 并阻塞当前线程。
* 与get()不同的是，如果到了规定时间，任务状态仍然是小于等于COMPLETING，
* 那么就抛出TimeoutException超时异常
*/
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
// 返回结果值或者抛出异常
return report(s);
}
两个方法最后都是返回report()方法，源码如下：
/**
* 返回运行结果，或者抛出异常。这个两种情况都表示FutureTask完结了
*/
@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
Object x = outcome;
// 表示正常完结状态，所以返回结果值
if (s == NORMAL)
return (V)x;
// 大于或等于CANCELLED，都表示手动取消FutureTask任务，
// 所以抛出CancellationException异常
if (s >= CANCELLED)
throw new CancellationException();
// 否则就是运行过程中，发生了异常，这里就抛出这个异常
throw new ExecutionException((Throwable)x);
}
运行FutureTask任务
运行FutureTask任务只要调用FutureTask任务的run方法，那么这个线程也是运行FutureTask任务的线程，取消任务时，可能会中断这个线程。
// 开始运行FutureTask任务
public void run() {
// 如果状态state不是NEW，或者设置runner值失败
// 表示有别的线程在此之前调用run方法，并成功设置了runner值
// 保证了只有一个线程可以运行try 代码块中的代码。
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
// 使用一个变量c记录callable，防止多线程情况下，
// callable直接被设置为null出现问题
Callable<V> c = callable;
// 只有c不为null且状态state为NEW的情况，
if (c != null && state == NEW) {
V result;
boolean ran;
try {
// 调用callable的call方法，并返回结果
result = c.call();
// 运行成功
ran = true;
} catch (Throwable ex) {
// 发生异常
result = null;
ran = false;
// 设置异常
setException(ex);
}
// 如果运行成功，则设置结果
if (ran)
set(result);
}
} finally {
runner = null;
int s = state;
// 当状态大于或等于INTERRUPTING，调用handlePossibleCancellationInterrupt方法，
// 等待别的线程将状态设置成INTERRUPTED
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
其实run方法作用非常简单，就是调用callable的call方法返回结果值result，根据是否发生异常，调用set(result)或setException(ex)方法表示FutureTask任务完结。
不过因为FutureTask任务都是在多线程环境中使用，所以要注意并发冲突问题。注意在run方法中，我们没有使用synchronized代码块或者Lock来解决并发问题，而是使用了CAS这个乐观锁来实现并发安全，保证只有一个线程能运行FutureTask任务。
取消FutureTask任务
public boolean cancel(boolean mayInterruptIfRunning) {
/**
* 如果当前状态不是NEW，或者使用CAS修改当前状态失败，那么直接返回false，取消失败
*/
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try {
// 如果能在运行时中断，那么就要调用运行FutureTask线程runner的interrupt方法
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
// 调用finishCompletion唤醒等待结果的线程
finishCompletion();
}
return true;
}
使用CAS函数来修改state状态，保证并发问题。如果mayInterruptIfRunning为true，那么会调用正在运行FutureTask任务线程的interrupt方法，发起中断请求，最后调用finishCompletion方法唤醒等待结果的线程。
等待结果的线程队列
/**
* 简单地单向链表的节点。记录着所有等待FutureTask运行结果的线程
*/
static final class WaitNode {
volatile Thread thread;
// 下一个节点
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}
/** 单向链表，记录着所有等待FutureTask运行结果的线程 */
private volatile WaitNode waiters;
将当前线程插入到等待队列中
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
// 计算截止日期
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
// 节点是否已添加
boolean queued = false;
for (;;) {
// 如果当前线程中断标志位是true，
// 那么从列表中移除节点q，并抛出InterruptedException异常
if (Thread.interrupted()) {
// 调用removeWaiter方法从链表中移除节点q
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
// 当状态大于COMPLETING时，表示FutureTask任务已结束。
if (s > COMPLETING) {
if (q != null)
// 将节点q线程设置为null，因为线程没有阻塞等待
q.thread = null;
return s;
}
// 表示还有一些后序操作没有完成，那么当前线程让出执行权
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
// 代码来到这里，表示状态是NEW，那么就需要将当前线程阻塞等待。
// 就是将它插入等待线程链表中，
else if (q == null)
// 使用当前线程创建节点p
q = new WaitNode();
//
else if (!queued)
// 使用CAS函数将新节点添加到链表中，如果添加失败，那么queued为false，
// 下次循环时，会继续添加，知道成功。
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
// timed为true表示需要设置超时
else if (timed) {
// 得到剩余时间
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
// 让当前线程等待nanos时间
LockSupport.parkNanos(this, nanos);
}
else
// 让当前线程阻塞等待
LockSupport.park(this);
}
}
我们可以深入removeWaiter()函数：
// 从链表中删除节点node
private void removeWaiter(WaitNode node) {
if (node != null) {
// 将thread设置null
node.thread = null;
retry:
for (;;) { // restart on removeWaiter race
for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
// 记录当前节点q的下一个节点s
s = q.next;
// 如果当前节点q的thread不等于null，那么就用pred记录q
if (q.thread != null)
pred = q;
// 如果当前节点q的thread等于null，且pred不等于null
else if (pred != null) {
// 删除当前节点q
pred.next = s;
// 如果pred.thread == null，那么继续retry的for循环
if (pred.thread == null) // check for race
continue retry;
}
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
q, s))
continue retry;
}
break;
}
}
}
唤醒等待结果的线程
/**
* 当FutureTask任务结束时(包括运行完成、抛出异常以及手动取消都表示任务结束)，都会调用这个方法。
* 用来唤醒所有等待运行结果的线程。
*/
private void finishCompletion() {
// assert state > COMPLETING;
// 这里使用CAS函数实现的乐观锁，保证只有一个线程能循环单向链表waiters
for (WaitNode q; (q = waiters) != null;) {
// 如果返回false，表示waiters被别的线程更改了，那么就再次循环。
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
// 循环等待结果的线程链表
for (;;) {
Thread t = q.thread;
// t不为null，那么就要唤醒等待线程
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
// 下一个节点
WaitNode next = q.next;
// next == null表示遍历到链表尾了。
if (next == null)
break;
// help gc
q.next = null;
q = next;
}
break;
}
}
// 钩子方法。子类可以复写这个方法。
done();
callable = null; // to reduce footprint
}
这个方法会在set()、setException()和cancel()方法中调用。
遍历等待结果的线程队列waiters，然后通过LockSupport.unpark(t)方法，唤醒被阻塞的线程
重复运行FutureTask任务
// 可以重复运行FutureTask任务
protected boolean runAndReset() {
// 如果状态state不是NEW，或者设置runner值失败
// 表示有别的线程在此之前调用run方法，并成功设置了runner值
// 保证了只有一个线程可以运行try 代码块中的代码。
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return false;
boolean ran = false;
int s = state;
try {
Callable<V> c = callable;
if (c != null && s == NEW) {
try {
// 注意这里没有获取结果值
// 因为任务可以重复执行，所以任务状态必须还是NEW。
// 不能调用set(result)方法改变任务状态
c.call();
ran = true;
} catch (Throwable ex) {
setException(ex);
}
}
} finally {
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
// 只有call方法调用成功且任务状态还是NEW，才可以再次执行任务
return ran && s == NEW;
}
runAndReset方法与run方法的区别就是当任务运行完毕后，不会调用set(result)方法，设置任务的结果值，改变任务的状态。所以可以重复调用runAndReset方法来多次运行任务。主要是为了定时线程池中，可以重复周期性地运行任务。
使用示范
package com.test;
import java.util.concurrent.Callable;
import java.util.concurrent.FutureTask;
public class FutureTaskTest {
public static void main(String[] args) {
final FutureTask<Integer> future = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
System.out.println("线程"+Thread.currentThread().getName()+"运行任务");
Thread.sleep(1000);
System.out.println("线程"+Thread.currentThread().getName()+"任务运行完成");
return 100;
}
});
new Thread(new Runnable() {
@Override
public void run() {
future.run();
}
}).start();;
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程1开始运行");
int result;
try {
//通过future获取结果
result = future.get();
System.out.println("线程1获取结果 result=="+result);
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("线程2开始运行");
int result;
try {
//通过future获取结果
result = future.get();
System.out.println("线程2获取结果 result=="+result);
} catch (Exception e) {
e.printStackTrace();
}
}
}).start();
}
}
结果：
本程序用一个线程跑future的计算，另外两个线程等待获取future的计算结果。
总结
创建了FutureTask和Callable对象，可以看出future.get()会等待Callable的call方法运行完毕。一般我们都是在线程池中使用Future和Callable，即ExecutorService的submit系列方法。
