先看一下参数
// 表示当前task状态
private volatile int state;
// 当前任务尚未执行
private static final int NEW = 0;
// 当前任务正在结束,尚未完全结束,一种临界状态。
private static final int COMPLETING = 1;
// 当前任务正常结束
private static final int NORMAL = 2;
// 当前任务执行过程中发生了异常,内部封装的callable.run(),向上抛出异常了
private static final int EXCEPTIONAL = 3;
// 当前任务被取消
private static final int CANCELLED = 4;
// 当前任务中断中。。。
private static final int INTERRUPTING = 5;
// 当前任务已中断
private static final int INTERRUPTED = 6;
// submit(runnable/callable) runnable使用装饰者模式 伪装成Callable了
private Callable<V> callable;
// 正常情况下:任务正常执行结束,outcome保存执行结果,callable返回值
// 非正常情况: callable向上抛出异常,outcome保存异常
private Object outcome; // non-volatile, protected by state reads/writes
// 当前任务线程执行期间,保存当前执行任务的线程对象引用
private volatile Thread runner;
// 因为会有很多线程去get当前任务的结果,所以,这里使用了一种数据结构 stack 头插 头取的一个队列
private volatile WaitNode waiters;
再看一下构造参数
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
// callable就是程序员自己实现的业务类
this.callable = callable;
// 设置当前状态为new
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
// 使用装饰者模式将runnable转换为了callable接口,外部线程通过get获取
// 当前任务执行结束时,结果可能为null 也有可能为传进来的值 总的来说 就是传啥返回啥
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
一般我们都不会直接调用构造方法,而是调用submit方法。
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;
}
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
看代码可知,最终将runnable注入到了callable中。
看一下run方法
// submit(runnable/callable) -> newTaskFor(runnable)->execute(task)->pool
// 任务执行入口
public void run() {
// 条件一:state!= NEW 条件成立,说明当前task已经被执行过了或者被cancel
// 总之非NEW状态的任务,线程就不处理了。
if (state != NEW ||
// 条件成立:cas失败,当前任务被其他线程抢占了、
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
// 执行到这里 当前task一定是NEW状态,而且当前线程也抢占TASK成功!
try {
// Callable 就是程序员自己封装逻辑的callable 或者装饰后的runnable
Callable<V> c = callable;
// 条件一: c != null 防止程序员传了null
// 条件二: state == NEW 方式外部线程 cancel掉当前线程
if (c != null && state == NEW) {
// 结果引用
V result;
// true 表示callable.run 代码块执行成功,未抛出异常
// false 表示callable.run 代码块执行失败 抛出异常
boolean ran;
try {
// 调用程序员自己实现的callable 或者装饰后的runnable
result = c.call();
ran = true;
} catch (Throwable ex) {
// 说明程序员是自己写的逻辑块有bug了
result = null;
ran = false;
setException(ex);
}
if (ran)
// 说明当前c.call正常执行结束了
// set就是设置结果到outcome
set(result);
}
} finally {
runner = null;
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
protected void set(V v) {
// 使用CAS方式设置当前任务状态为 完成中
// 有没有可能失败呢?外部线程等不及了,直接在set执行cas之前给取消掉了、
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
// 将结果赋值给outcome之后,马上会将当前任务状态修改为NORMAL 正常结束状态
UNSAFE.putOrderedInt(this, stateOffset, NORMAL);
finishCompletion();
}
}
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
private void finishCompletion() {
// assert state > COMPLETING;
// q指向waiters链表的头节点
for (WaitNode q; (q = waiters) != null;) {
// 当前头节点设为null,用cas是因为怕外部线程使用cancel取消当前任务 也会触发finishCompletion 小概率时间
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
// 获取当前node节点封装的thread
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方法
// 场景:多个线程等待当前任务执行完成后的结果
public V get() throws InterruptedException, ExecutionException {
// 获取当前任务状态
int s = state;
// 条件成立:未执行 正在执行 正完成 调用get的外部线程会被阻塞在get方法上。
if (s <= COMPLETING)
// 返回task当前状态 可能当前线程在里面已经睡了一会了
s = awaitDone(false, 0L);
return report(s);
}
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
// 假设deadline = 0 不带超时
final long deadline = timed ? System.nanoTime() + nanos : 0L;
// 引用当前线程 封装成WaitNode对象
WaitNode q = null;
// 表示当前线程 waitNode对象 有没有入队/压栈
boolean queued = false;
// 自旋
for (;;) {
// 条件成立:说明当前线程唤醒 是被其他线程使用中断这种方式唤醒的 interrupted()
返回true后会将thread的中断标记重置为false
if (Thread.interrupted()) {
// 出栈
removeWaiter(q);
// get方法抛出 中断异常
throw new InterruptedException();
}
// 假设当前线程是被其他线程 使用unpark(thread) 唤醒的话 会正常自旋 走下面逻辑
int s = state;
// 条件成立 说明当前任务 已经有结果了 可能是好 可能是坏
if (s > COMPLETING) {
// 条件成立 说明已经为当前线程创建过node 此时需要将node.thread = null help gc
if (q != null)
q.thread = null;
// 直接返回当前状态
return s;
}
// 条件成立 说明当前任务接近完成状态 这里让当前线程再释放cpu 进行下一次抢占cpu
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
// 第一次先进这里 当前线程还未创建waitNode对象 此时为当前线程创建waitNode对象
else if (q == null)
q = new WaitNode();
// 条件成立 第二次自旋,当前线程已经创建waitNode对象 但是node对象还未入队
else if (!queued)
// 当前线程node节点 next指向 原队列的头结点 waiters一直指向对象的头
// CAS方式设置waiters引用指向 当前线程node,成功的话 queued == true
// 否则其他线程先你一步入队列。
// 其实就是将q的后面接上现存的栈,相当于入栈了
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
// 第三次自旋 会进入这里 假设timed = 0
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
// 当前get操作的线程会被park。线程状态会变为WAITING状态,相当于休眠了。。。
// 除非有其他线程将你唤醒 或者 将当前线程 中断。
else
LockSupport.park(this);
}
}
private V report(int s) throws ExecutionException {
// 正常情况下 outcome 保存的是callable运行结束的结果
// 非正常 保存的是callable抛出的异常
Object x = outcome;
// 条件成立 当前任务状态正常结束
if (s == NORMAL)
return (V)x;
// 被中断了
if (s >= CANCELLED)
throw new CancellationException();
// 执行到这 说明你的线程有bug了
throw new ExecutionException((Throwable)x);
}