package java.util.concurrent;
import java.util.concurrent.locks.LockSupport;
public class FutureTask<V> implements RunnableFuture<V> {
private volatile int state;
//初始状态,未执行run
private static final int NEW = 0;
private static final int COMPLETING = 1;
//状态代表任务正常执行并返回
private static final int NORMAL = 2;
//运行任务时发生了异常
private static final int EXCEPTIONAL = 3;
//调用了cancel(false),取消任务但不发送中断
private static final int CANCELLED = 4;
//调用了cancel(true),取消任务且发送中断,中断前设置状态INTERRUPTING
private static final int INTERRUPTING = 5;
//调用了cancel(true),取消任务且发送中断,中断后设置状态INTERRUPTED
private static final int INTERRUPTED = 6;
//底层要运行的任务,运行完毕将callable引用设置为null
private Callable<V> callable;
//存放callable执行的结果或运行callable任务时抛出的异常实例
//这个属性不是volatile的!!!(了解happens-before原则)
private Object outcome; // non-volatile, protected by state reads/writes
//执行任务的线程,在run方法中设置为当前运行线程
private volatile Thread runner;
//任务返回结果前调用get阻塞后将线程保存到waiters栈中
private volatile WaitNode waiters;
/**
* 返回结果或抛异常会从awaitDone唤醒后并执行此方法,
* 由get方法调用返回结果
*/
@SuppressWarnings("unchecked")
private V report(int s) throws ExecutionException {
Object x = outcome;
//正常结束,outcome为callable的返回值
//异常结束,outcome为捕获的异常实例
if (s == NORMAL)
return (V)x;
//如果是取消了任务,抛出CancellationException
if (s >= CANCELLED)
throw new CancellationException();
//如果因callable任务内抛异常而结束,那么抛ExecutionException
//x为callable抛出的异常
throw new ExecutionException((Throwable)x);
}
//创建一个FutureTask实例并指定要执行的任务,FutureTask本身也是一个
//Runnable需要由线程执行
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
//由于Runnable是返回void的方法那么将runnable包装成Callable,
//并在任务执行完毕后返回传入的result
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
public boolean isCancelled() {
return state >= CANCELLED;
}
public boolean isDone() {
return state != NEW;
}
//取消一个任务,取消分两种情况
//1.不发送中断,即入参是false,此情况下,只设置当前FutureTask的状态
// 为CANCELLED,并唤醒因get操作等待的线程,此时一切get操作将抛
// java.util.concurrent.CancellationException,实际上内部并没有终止正在运行的任务
//2. 发送中断,即入参是true,此时会向当前运行任务的线程发送一个中断,
// 发送前设置状态是INTERRUPTING,发送后设置状态为INTERRUPTED,
// 然后唤醒因get操作等待的线程,此时一切get操作将抛
// java.util.concurrent.CancellationException
public boolean cancel(boolean mayInterruptIfRunning) {
if (!(state == NEW &&
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
return false;
try { // in case call to interrupt throws exception
if (mayInterruptIfRunning) {
try {
Thread t = runner;
if (t != null)
//向当前运行任务的线程发送中断
//当前线程可以是线程池的工作线程
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
/**
* 获取callable任务执行的结果,任务未结束则等待
*/
public V get() throws InterruptedException, ExecutionException {
int s = state;
//set方法在设置outcome之前会将状态改成COMPLETING
//然后更新outcome再更新状态为NORMAL(任务正常执行返回)
//因此除非看到状态为NORMAL,EXCEPTIONAL,CANCELLED,INTERRUPTING,INTERRUPTED
//之一,否则需要等待
if (s <= COMPLETING)
s = awaitDone(false, 0L);//调用非超时的等待方法
//一旦能看到大于COMPLETING的状态那么outcome必定对所有线程可见
//根据happends-before原则对volatile state的读先于对其的写
return report(s);
}
/**
* 获取callable任务执行的结果,任务未结束则等待,直到超时抛TimeoutException
*/
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
protected void done() { }
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
//调用putIntVolatile的延时版本,修改的值对其它线程不会立即可见
//那么如何保证其它线程获取的值是最新的?
//另一个线程必须在看到状态值是NORMAL后才能去获取coutcome的值
//(使用的volatile state传递性及happens-before规则)
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
//唤醒等待线程并执行done回调方法
finishCompletion();
}
}
//执行callable抛异常那么设置异常状态及值
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;//任务运行发生异常,outcome保存异常实例
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
//唤醒等待线程并执行done回调方法
finishCompletion();
}
}
public void run() {
if (state != NEW ||//当前状态不是NEW则返回,否则将runner设置为当前线程
!UNSAFE.compareAndSwapObject(this, runnerOffset,//多个线程无法同时运行run,因为runner只能成功设置一次
null, Thread.currentThread()))
return;
try {
//当前FutureTask要执行的callable
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//执行底层callable的call方法
result = c.call();
//成功执行设置为true
ran = true;
} catch (Throwable ex) {//捕获根异常
result = null;
ran = false;
//执行任务抛异常设置当前状态为COMPLETING->EXCEPTIONAL
//并将ex保存到outcome中
setException(ex);
}
//执行成功(c.call()未抛异常)
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)
//等待cancel(true)方法中interrupt调用结束
handlePossibleCancellationInterrupt(s);
}
}
//ScheduledThreadPoolExecutor执行此调用,目的是可以重复执行runAndReset方法
//而默认的run方法不可以重复执行,因为run执行完毕后状态会变成NORMAL而非NEW
//因而不可重复执行
protected boolean runAndReset() {
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不变,
//除非取消或发生了异常
c.call();
ran = true;
} catch (Throwable ex) {
setException(ex);
}
}
} 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
s = state;
if (s >= INTERRUPTING)
//等待cancel(true)方法中interrupt调用结束
handlePossibleCancellationInterrupt(s);
}
return ran && s == NEW;
}
private void handlePossibleCancellationInterrupt(int s) {
// It is possible for our interrupter to stall before getting a
// chance to interrupt us. Let's spin-wait patiently.
if (s == INTERRUPTING)
//等待cancel(true)方法中interrupt调用结束
while (state == INTERRUPTING)
Thread.yield(); // wait out pending interrupt
// assert state == INTERRUPTED;
// We want to clear any interrupt we may have received from
// cancel(true). However, it is permissible to use interrupts
// as an independent mechanism for a task to communicate with
// its caller, and there is no way to clear only the
// cancellation interrupt.
//
// Thread.interrupted();
}
/**
* Simple linked list nodes to record waiting threads in a Treiber
* stack. See other classes such as Phaser and SynchronousQueue
* for more detailed explanation.
*/
static final class WaitNode {
volatile Thread thread;
volatile WaitNode next;
WaitNode() { thread = Thread.currentThread(); }
}
/**
* 任务执行完成后(正常结束或异常结束)唤醒等待FutureTask完成的线程
*/
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
//将waiters栈设置为null
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
//for循环中挨个唤醒线程
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
//调用done回调,默认空实现
done();
//将callable设置为null
callable = null; // to reduce footprint
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//当前调用get的线程被中断那么从等待栈中移除并抛异常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//大于COMPLETING的状态为:NORMAL,EXCEPTIONAL,CANCELLED,INTERRUPTING,INTERRUPTED
//说明任务结束,方法返回
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//状态为COMPLETING,那么等待set操作完成(set,或setException),
//让其它线程运行
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
else if (q == null)
//任务未完成,创建一个WaitNode入队
//并准备挂起当前线程
q = new WaitNode();
else if (!queued)//q被null且还未入队,则入队
//比较并设置,失败自旋重试,这里每次插入的head位置
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}
private void removeWaiter(WaitNode node) {
if (node != null) {
//先将thread属性设置成null,然后在下面的for循环中删除
//thread属性为null的节点
node.thread = null;
retry:
for (;;) { // restart on removeWaiter race
for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
s = q.next;//当前遍历节点的下一个
if (q.thread != null)
pred = q;
else if (pred != null) {
pred.next = s;
if (pred.thread == null) // check for race
continue retry;
}
//删除的左边的头(第一个)结点,那么将waiters设置为第一个节点的next
else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
q, s))
continue retry;
}
break;
}
}
}
// Unsafe mechanics
private static final sun.misc.Unsafe UNSAFE;
private static final long stateOffset;
private static final long runnerOffset;
private static final long waitersOffset;
static {
try {
UNSAFE = sun.misc.Unsafe.getUnsafe();
Class<?> k = FutureTask.class;
stateOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("state"));
runnerOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("runner"));
waitersOffset = UNSAFE.objectFieldOffset
(k.getDeclaredField("waiters"));
} catch (Exception e) {
throw new Error(e);
}
}
}