//以下五個(gè)方法實(shí)現(xiàn)接口Future中方法
public boolean isCancelled(); 
public boolean isDone(); 
public boolean cancel();
public V get() throws InterruptedException, ExecutionException;
public V get(long timeout, TimeUnit unit);
//實(shí)現(xiàn)接口Runnable中方法
public void run();

/**
* Created by yuanqiongqiong on 2019/4/9.
*/
public class FutureTaskTest {
private static ExecutorService executorService = Executors.newFixedThreadPool(1);
public static void main(String []args) {
Callable callable = new AccCallable(1, 2);
FutureTask futureTask = new FutureTask(callable);
executorService.execute(futureTask);
System.out.println("go to do other things in main thread");
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("go back in main thread");
try {
int result = (int) futureTask.get();
System.out.println("result is " + result);
} catch (InterruptedException e) {
e.printStackTrace();
} catch (ExecutionException e) {
e.printStackTrace();
}
}
static class AccCallable implements Callable<Integer> {
private int a;
private int b;
public AccCallable(int a, int b) {
this.a = a;
this.b = b;
}
@Override
public Integer call() throws Exception {
System.out.println("acc a and b in threadId = " + Thread.currentThread().getName());
return a + b;
}
}
}

go to do other things in main thread
acc a and b in threadId = pool-1-thread-1
go back in main thread
result is 3

//futureTask執(zhí)行狀態(tài)
private volatile int state;
//具體的執(zhí)行任務(wù)，會(huì)在run方法中抵用callable.call()
private Callable<V> callable;
//執(zhí)行結(jié)果
private Object outcome; 
//獲取結(jié)果的等待線程節(jié)點(diǎn)
private volatile WaitNode waiters;

/**
* Possible state transitions:
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
*/
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;

public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
public FutureTask(Runnable runnable, V result) {
//構(gòu)造函數(shù)傳入runnable對(duì)象時(shí)調(diào)用靜態(tài)工具類Executors的方法轉(zhuǎn)換為一個(gè)callable對(duì)象
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}

public void run() {
//1.如果執(zhí)行狀態(tài)不是NEW或者有其他線程執(zhí)行該任務(wù)，直接返回
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
//2.如果執(zhí)行狀態(tài)是NEW,即任務(wù)還沒執(zhí)行，直接調(diào)用callable.call()方法獲取執(zhí)行結(jié)果
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
//3.發(fā)生異常，更新status為EXCEPTIONAL，喚醒掛起線程
setException(ex);
}
//4.如果結(jié)果成功返回，調(diào)用set方法將設(shè)置outcome，更改status執(zhí)行狀態(tài)，喚醒掛起線程
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);
}
}

protected void set(V v) {
//將執(zhí)行狀態(tài)變更為COMPLETING
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
//設(shè)置執(zhí)行結(jié)果
outcome = v;
//設(shè)置執(zhí)行狀態(tài)為NORMAL
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
//執(zhí)行完成后處理操作，具體就是遍歷阻塞鏈表，刪除鏈表節(jié)點(diǎn)，并喚醒每個(gè)節(jié)點(diǎn)關(guān)聯(lián)的線程
finishCompletion();
}
}

public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
//執(zhí)行狀態(tài)是NEW或者COMPLETING時(shí)執(zhí)行awaitDone將線程加入等待隊(duì)列中并掛起線程
if (s <= COMPLETING &&
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
//根據(jù)執(zhí)行狀態(tài)status進(jìn)行結(jié)果封裝
return report(s);
}
//我理解這塊是get的核心邏輯
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
//如果設(shè)置了超時(shí)時(shí)間，計(jì)算還有多長(zhǎng)時(shí)間超時(shí)
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//如果當(dāng)前線程被中斷，刪除等待隊(duì)列中的節(jié)點(diǎn)，并拋出異常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
//如果執(zhí)行狀態(tài)已經(jīng)完成或者發(fā)生異常，直接跳出自旋返回
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
//如果執(zhí)行狀態(tài)是正在執(zhí)行，說明線程已經(jīng)被加入到等待隊(duì)列中，放棄cpu進(jìn)入下次循環(huán)(真正的自旋)
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
//第一次進(jìn)入循環(huán)，創(chuàng)建節(jié)點(diǎn)
else if (q == null)
q = new WaitNode();
//將節(jié)點(diǎn)加入到等待隊(duì)列中，waiters相當(dāng)于頭階段，不斷將頭結(jié)點(diǎn)更新為新節(jié)點(diǎn)
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
else if (timed) {
//如果設(shè)置了超時(shí)時(shí)間，在進(jìn)行下次循環(huán)前查看是否已經(jīng)超時(shí)，如果超時(shí)刪除該節(jié)點(diǎn)進(jìn)行返回
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
//掛起當(dāng)前節(jié)點(diǎn)
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}