public class FutureTaskDemo {
    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new Callable() {
            @Override
            public Object call() throws Exception {
                System.out.println("異步線程執(zhí)行");
                Thread.sleep(3000);//模擬線程執(zhí)行任務(wù)需要3秒
                return "ok";
            }
        });
        Thread t1 = new Thread(futureTask, "線程一");
        t1.start();

        try {
            //關(guān)鍵代碼
            String s = futureTask.get(2, TimeUnit.SECONDS); //最大等待線程2秒
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
    }
}

  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) //重點(diǎn)awaitDone，即完成了最大等待，依然沒有結(jié)果就拋出異常邏輯
            throw new TimeoutException();
        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) // cannot time out yet
                Thread.yield();
            else if (q == null)
                q = new WaitNode();
            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);
        }
    }

static final class WaitNode {
        volatile Thread thread;
        volatile WaitNode next;
        WaitNode() { thread = Thread.currentThread(); }
    }

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;
state可能轉(zhuǎn)換的過程 
    1.NEW -> COMPLETING -> NORMAL (成功完成)
    2.NEW -> COMPLETING -> EXCEPTIONAL (異常)
    3.NEW -> CANCELLED (任務(wù)被取消)
    4.NEW -> INTERRUPTING -> INTERRUPTED(任務(wù)被打斷)

LockSupport.park(this, nanos) ==內(nèi)部實(shí)現(xiàn)==> UNSAFE.park(false, nanos)();

 public FutureTask(Runnable runnable, V result) {
     this.callable = Executors.callable(runnable, result);
     this.state = NEW;   // 賦值狀態(tài)
 }

public void run() {
        ..........防止多次運(yùn)行stat()方法..............
        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;
    		//----最后結(jié)束---防止線程被打斷
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }

protected void setException(Throwable t) {
    if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
        outcome = t;
        UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
        finishCompletion();
        //軌跡變化 2.NEW -> COMPLETING -> EXCEPTIONAL (異常)
    }
    //否則1： 3.NEW -> CANCELLED (任務(wù)被取消)
    //否則2： 4.NEW -> INTERRUPTING -> INTERRUPTED(任務(wù)被打斷)
}