/**
 * 在构建FutureTask时设置，同时也表示内部成员callable已成功赋值
 * 一直到worker thread完成FutureTask中的run()
 */
private static final int NEW          = 0;
/**
 * worker thread在处理task时设定的中间状态，处于该状态时，说明worker thread正准备设置result
 */
private static final int COMPLETING   = 1;
/**
 * 当设置result结果完成后，FutureTask处于该状态，代表过程结果。
 * 该状态为最终状态final state。（正确完成的最终状态）
 */
private static final int NORMAL       = 2;
/**
 * 同上，只不过task执行过程出现异常，此时结果设置为exception，也是final state
 */
private static final int EXCEPTIONAL  = 3;
/**
 * final state，表明task被cancel（task还没有执行就被cancel的状态）
 */
private static final int CANCELLED    = 4;
/**
 * 中间状态，task运行过程中被interrupt时，设置的中间状态
 */
private static final int INTERRUPTING = 5;
/**
 * final state，中断完毕的最终状态
 */
private static final int INTERRUPTED  = 6;

// 用来执行的任务
private Callable<V> callable;
// 用来保存任务的成功执行的结果后者执行任务时发生异常的Exception对象
private Object outcome; 
// 执行Callable任务的线程
private volatile Thread runner;
// 调用get方法获取任务执行结果时被阻塞的线程栈
private volatile WaitNode waiters;

// 维护等待在此FutureTask上的线程, volatile保证了线程间的可见性, 因为需要CAS操作
static final class WaitNode {
    volatile Thread thread;
    volatile WaitNode next;
    WaitNode() { thread = Thread.currentThread(); }
}

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 = null;
    int s = state;
    if (s >= INTERRUPTING)
      handlePossibleCancellationInterrupt(s);
  }
}

public V get() throws InterruptedException, ExecutionException {
  int s = state;
  if (s <= COMPLETING)
    // 阻塞直到COMPLETING或中断
    s = awaitDone(false, 0L);
  return report(s);
}

private int awaitDone(boolean timed, long nanos)
  throws InterruptedException {
  final long deadline = timed ? System.nanoTime() + nanos : 0L;
  WaitNode q = null;
  boolean queued = false;
  // 线程自旋
  for (;;) {
    // 响应中断
    if (Thread.interrupted()) {
      removeWaiter(q);
      throw new InterruptedException();
    }

    int s = state;
    // 返回
    if (s > COMPLETING) {
      if (q != null)
        q.thread = null;
      return s;
    }
    // 让出时间片给工作线程
    else if (s == COMPLETING)
      Thread.yield();
    else if (q == null)
      q = new WaitNode();
    // 添加线程到waiters等待队列, 完成后唤醒
    else if (!queued)
      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 final class Worker extends AbstractQueuedSynchronizer implements Runnable{
  final Thread thread;
  Runnable firstTask;
  ...
}

final void runWorker(Worker w) {
  Thread wt = Thread.currentThread();
  Runnable task = w.firstTask;
  w.firstTask = null;
  w.unlock(); // allow interrupts
  boolean completedAbruptly = true;
  try {
    while (task != null || (task = getTask()) != null) {
      w.lock();
      if ((runStateAtLeast(ctl.get(), STOP) ||
           (Thread.interrupted() &&
            runStateAtLeast(ctl.get(), STOP))) &&
          !wt.isInterrupted())
        wt.interrupt();
      try {
        beforeExecute(wt, task);
        Throwable thrown = null;
        try {
          task.run();
        } catch (RuntimeException x) {
          thrown = x; throw x;
        } catch (Error x) {
          thrown = x; throw x;
        } catch (Throwable x) {
          thrown = x; throw new Error(x);
        } finally {
          afterExecute(task, thrown);
        }
      } finally {
        task = null;
        w.completedTasks++;
        w.unlock();
      }
    }
    completedAbruptly = false;
  } finally {
    processWorkerExit(w, completedAbruptly);
  }
}

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
  if (!e.isShutdown()) {
    r.run();
  }
}

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
  throw new RejectedExecutionException("Task " + r.toString() +
                                       " rejected from " +
                                       e.toString());
}

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
}

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
  if (!e.isShutdown()) {
    e.getQueue().poll();
    e.execute(r);
  }
}

public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
  try {
    Thread t = new Thread(r, "Temporary task executor");
    t.start();
  } catch (Throwable var4) {
    throw new RejectedExecutionException("Failed to start a new thread", var4);
  }
}