先來看看 線程池框架的 繼承結(jié)構(gòu):
public interface Executor {
/**
*Executor，任務(wù)的執(zhí)行者，線程池框架中幾乎所有類都直接或者間接實 現(xiàn)Executor接口，它是線程池框架的基礎(chǔ)。
*Executor提供了一種將“任務(wù)提交”與“任務(wù)執(zhí)行”分離開來的機制，
*它僅提供了一個Execute()方法用來執(zhí)行已經(jīng)提交的Runnable任務(wù)。
*/
void execute(Runnable command);
}
public interface ExecutorService extends Executor {
/**
* 啟動一次順序關(guān)閉，執(zhí)行以前提交的任務(wù)，但不接受新任務(wù)
*/
void shutdown();
/**
* 試圖停止所有正在執(zhí)行的活動任務(wù)，暫停處理正在等待的任務(wù)，并返回等待執(zhí)行的任務(wù)列表
*/
List<Runnable> shutdownNow();
/**
* 試圖停止所有正在執(zhí)行的活動任務(wù)，暫停處理正在等待的任務(wù)，并返回等待執(zhí)行的任務(wù)列表
*/
boolean isShutdown();
/**
* 試圖停止所有正在執(zhí)行的活動任務(wù)，暫停處理正在等待的任務(wù)，并返回等待執(zhí)行的任務(wù)列表
*/
boolean isTerminated();
/**
*接收人timeout和TimeUnit兩個參數(shù)，用于設(shè)定超時時間及單位。
*當?shù)却^設(shè)定時間時，會監(jiān)測ExecutorService是否已經(jīng)關(guān)閉，若關(guān)閉則返回true，否則返回false。
*一般情況下會和shutdown方法組合使用
*/
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
/**
* 提交一個返回值的任務(wù)用于執(zhí)行，返回一個表示任務(wù)的未決結(jié)果的 Future
*/
<T> Future<T> submit(Callable<T> task);
/**
*為執(zhí)行提交一個可運行的任務(wù)，并返回一個表示該任務(wù)的未來。
*未來的方法將在成功完成后返回給定的結(jié)果。
*/
<T> Future<T> submit(Runnable task, T result);
/**
* 提交一個返回值的任務(wù)用于執(zhí)行，返回一個表示任務(wù)的未決結(jié)果的 Future
*/
Future<?> submit(Runnable task);
/**
* 執(zhí)行給定的任務(wù)，返回一個在所有完成時保持其狀態(tài)和結(jié)果的未來列表。
*注意，任務(wù)可以正常終止，也可以拋出異常。
*如果在此操作正在進行時對給定的集合進行修改，則該方法的結(jié)果是未定義的。
*
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
throws InterruptedException;
/**
* 執(zhí)行給定的任務(wù)，當所有任務(wù)完成或超時期滿時
*（無論哪個首先發(fā)生），返回保持任務(wù)狀態(tài)和結(jié)果的 Future 列表
*/
<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
/**
*提交的任務(wù)集合,一旦有1個任務(wù)正常完成(沒有拋出異常),會終止其他未完成的任務(wù)
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks)
throws InterruptedException, ExecutionException;
/**
* 執(zhí)行給定的任務(wù)，如果在給定的超時期滿前某個任務(wù)已成功完成（也就是未拋出異常），
* 則返回其結(jié)果
*/
<T> T invokeAny(Collection<? extends Callable<T>> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
有關(guān)submit 和 invokeAll的方法實例的寫在這里
Future
Future接口
作為異步計算的頂層接口，F(xiàn)uture對具體的Runnable或者Callable任務(wù)提供了三種操作：執(zhí)行任務(wù)的取消、查詢?nèi)蝿?wù)是否完成、獲取任務(wù)的執(zhí)行結(jié)果。其接口定義如下：
*/
public interface Future<V> {
/**
* 試圖取消對此任務(wù)的執(zhí)行
* 如果任務(wù)已完成、或已取消，或者由于某些其他原因而無法取消，則此嘗試將失敗。
* 當調(diào)用 cancel 時，如果調(diào)用成功，而此任務(wù)尚未啟動，則此任務(wù)將永不運行。
* 如果任務(wù)已經(jīng)啟動，則 mayInterruptIfRunning 參數(shù)確定是否應(yīng)該以試圖停止任務(wù)的方式來中斷執(zhí)行此任務(wù)的線程
*/
boolean cancel(boolean mayInterruptIfRunning);
/**
* 如果在任務(wù)正常完成前將其取消，則返回 true
*/
boolean isCancelled();
/**
* 如果任務(wù)已完成，（無論是否拋異常）則返回 true
*/
boolean isDone();
/**
* 阻塞獲取，等待計算完成，然后獲取其結(jié)果
*/
V get() throws InterruptedException, ExecutionException;
/**
* 如有必要，最多等待為使計算完成所給定的時間之后，獲取其結(jié)果（如果結(jié)果可用）
*/
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
FutureTask
實現(xiàn)RunnableFuture接口，既可以作為Runnable被執(zhí)行，也可以作為Future得到Callable的返回值。
構(gòu)造函數(shù)
- 先從FutureTask的構(gòu)造函數(shù)看起，F(xiàn)utureTask有兩個構(gòu)造函數(shù)，其中一個如下：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
這個構(gòu)造函數(shù)會把傳入的Callable變量保存在this.callable字段中，該字段定義為private Callable<V> callable;用來保存底層的調(diào)用，在被執(zhí)行完成以后會指向null,接著會初始化state字段為NEW。state字段用來保存FutureTask內(nèi)部的任務(wù)執(zhí)行狀態(tài)，一共有7中狀態(tài)，每種狀態(tài)及其對應(yīng)的值如下：
private volatile int state;
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;
* Possible state transitions:
* NEW -> COMPLETING -> NORMAL
* NEW -> COMPLETING -> EXCEPTIONAL
* NEW -> CANCELLED
* NEW -> INTERRUPTING -> INTERRUPTED
為了后面更好的分析FutureTask的實現(xiàn)，這里有必要解釋下各個狀態(tài)。
NEW:表示是個新的任務(wù)或者還沒被執(zhí)行完的任務(wù)。這是初始狀態(tài)。
COMPLETING:任務(wù)已經(jīng)執(zhí)行完成或者執(zhí)行任務(wù)的時候發(fā)生異常，但是任務(wù)執(zhí)行結(jié)果或者異常原因還沒有保存到outcome字段(outcome字段用來保存任務(wù)執(zhí)行結(jié)果，如果發(fā)生異常，則用來保存異常原因)的時候，狀態(tài)會從NEW變更到CO- MPLETING。但是這個狀態(tài)會時間會比較短，屬于中間狀態(tài)。
NORMAL:任務(wù)已經(jīng)執(zhí)行完成并且任務(wù)執(zhí)行結(jié)果已經(jīng)保存到outcome字段，狀態(tài)會從COMPLETING轉(zhuǎn)換到NORMAL。這是一個最終態(tài)。
EXCEPTIONAL:任務(wù)執(zhí)行發(fā)生異常并且異常原因已經(jīng)保存到outcome字段中后，狀態(tài)會從COMPLETING轉(zhuǎn)換到EXCEPTIONAL。這是一個最終態(tài)。
CANCELLED:任務(wù)還沒開始執(zhí)行或者已經(jīng)開始執(zhí)行但是還沒有執(zhí)行完成的時候，用戶調(diào)用了cancel(false)方法取消任務(wù)且不中斷任務(wù)執(zhí)行線程，這個時候狀態(tài)會從NEW轉(zhuǎn)化為CANCELLED狀態(tài)。這是一個最終態(tài)。
INTERRUPTING: 任務(wù)還沒開始執(zhí)行或者已經(jīng)執(zhí)行但是還沒有執(zhí)行完成的時候，用戶調(diào)用了cancel(true)方法取消任務(wù)并且要中斷任務(wù)執(zhí)行線程但是還沒有中斷任務(wù)執(zhí)行線程之前，狀態(tài)會從NEW轉(zhuǎn)化為INTERRUPTING。這是一個中間狀態(tài)。
INTERRUPTED:調(diào)用interrupt()中斷任務(wù)執(zhí)行線程之后狀態(tài)會從INTERRUPTING轉(zhuǎn)換到INTERRUPTED。這是一個最終態(tài)。
有一點需要注意的是，所有值大于COMPLETING的狀態(tài)都表示任務(wù)已經(jīng)執(zhí)行完成(任務(wù)正常執(zhí)行完成，任務(wù)執(zhí)行異?；蛘呷蝿?wù)被取消)。
另一個 構(gòu)造函數(shù)：
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
//這個構(gòu)造函數(shù)會把傳入的Runnable封裝成一個Callable對象保存在callable字段中，
//同時如果任務(wù)執(zhí)行成功的話就會返回傳入的result。
//這種情況下如果不需要返回值的話可以傳入一個null。
//順帶看下Executors.callable()這個方法，
//這個方法的功能是把Runnable轉(zhuǎn)換成Callable，代碼如下:
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
//可以看到這里采用的是適配器模式，調(diào)用RunnableAdapter<T>(task, result)方法來適配，實現(xiàn)如下:
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
這個適配器很簡單，就是簡單的實現(xiàn)了Callable接口，在call()實現(xiàn)中調(diào)用Runnable.run()方法，然后把傳入的result作為任務(wù)的結(jié)果返回。
在new了一個FutureTask對象之后，接下來就是在另一個線程中執(zhí)行這個Task,無論是通過直接new一個Thread還是通過線程池，執(zhí)行的都是run()方法，接下來就看看
run()方法的實現(xiàn)。
public void run() {
// 1. 狀態(tài)如果不是NEW，說明任務(wù)或者已經(jīng)執(zhí)行過，或者已經(jīng)被取消，直接返回
// 2. 狀態(tài)如果是NEW，則嘗試把當前執(zhí)行線程保存在runner字段中
// 如果賦值失敗則直接返回
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 {
// 3. 執(zhí)行任務(wù)
result = c.call();
ran = true;
} catch (Throwable ex) {
//4.執(zhí)行任務(wù)失敗
result = null;
ran = false;
//將異常保存至 outcome字段
setException(ex);
}
if (ran)//如果成功保存結(jié)果字段
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;
// 5. 如果任務(wù)被中斷，執(zhí)行中斷處理
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
run()方法首先會
- 判斷當前任務(wù)的state是否等于NEW,如果不為NEW則說明任務(wù)或者已經(jīng)執(zhí)行過，或者已經(jīng)被取消，直接返回。
- 如果狀態(tài)為NEW則接著會通過unsafe類把任務(wù)執(zhí)行線程引用CAS的保存在runner字段中，如果保存失敗，則直接返回。
- 執(zhí)行任務(wù)。
- 如果任務(wù)執(zhí)行發(fā)生異常，則調(diào)用setException()方法保存異常信息。
setException()方法如下：
protected void setException(Throwable t) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = t;
UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
finishCompletion();
}
}
setException（）
- 首先會CAS的把當前的狀態(tài)從NEW變更為COMPLETING狀態(tài)。
- 把異常原因保存在outcome字段中，outcome字段用來保存任務(wù)執(zhí)行結(jié)果或者異常原因。
- CAS的把當前任務(wù)狀態(tài)從COMPLETING變更為EXCEPTIONAL。這個狀態(tài)轉(zhuǎn)換對應(yīng)著上圖中的
- 調(diào)用finishCompletion()。關(guān)于這個方法后面在分析。
任務(wù)成功調(diào)用
set(V v)方法 如下：
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();
}
}
這個方法跟上面分析的setException()差不多，
- 首先會CAS的把當前的狀態(tài)從NEW變更為COMPLETING狀態(tài)。
把任務(wù)執(zhí)行結(jié)果保存在outcome字段中。 - CAS的把當前任務(wù)狀態(tài)從COMPLETING變更為NORMAL。這個狀態(tài)轉(zhuǎn)換對應(yīng)著上圖中的一。
- 調(diào)用finishCompletion()。
get()
任務(wù)發(fā)起線程可以調(diào)用get()方法來獲取任務(wù)執(zhí)行結(jié)果，如果此時任務(wù)已經(jīng)執(zhí)行完畢則會直接返回任務(wù)結(jié)果，如果任務(wù)還沒執(zhí)行完畢，則調(diào)用方會阻塞直到任務(wù)執(zhí)行結(jié)束返回結(jié)果為止。get()方法實現(xiàn)如下:
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L);
return report(s);
}
get()方法實現(xiàn)比較簡單，
- 會判斷任務(wù)當前的state <= COMPLETING是否成立。前面分析過，COMPLETING狀態(tài)是任務(wù)是否執(zhí)行完成的臨界狀態(tài)。
- 如果成立，表明任務(wù)還沒有結(jié)束(這里的結(jié)束包括任務(wù)正常執(zhí)行完畢，任務(wù)執(zhí)行異常，任務(wù)被取消)，則會調(diào)用awaitDone()進行阻塞等待。
- 如果不成立表明任務(wù)已經(jīng)結(jié)束，調(diào)用report()返回結(jié)果。
awaitDone()
當調(diào)用get()獲取任務(wù)結(jié)果但是任務(wù)還沒執(zhí)行完成的時候，調(diào)用線程會調(diào)用awaitDone()方法進行阻塞等待，該方法定義如下:
/**
* Awaits completion or aborts on interrupt or timeout.
*
* @param timed true if use timed waits
* @param nanos time to wait, if timed
* @return state upon completion
*/
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
// 計算等待截止時間
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;
boolean queued = false;
for (;;) {
//1.判斷當前線程是否阻塞,
//如果被中斷則在等待隊列中刪除該節(jié)點并拋出InterruptedException異常
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
// 2. 獲取當前狀態(tài)，如果狀態(tài)大于COMPLETING
// 說明任務(wù)已經(jīng)結(jié)束(要么正常結(jié)束，要么異常結(jié)束，要么被取消)
// 則把thread顯示置空，并返回結(jié)果
int s = state;
if (s > COMPLETING) {
if (q != null)
q.thread = null;
return s;
}
// 3. 如果狀態(tài)處于中間狀態(tài)COMPLETING
// 表示任務(wù)已經(jīng)結(jié)束但是任務(wù)執(zhí)行線程還沒來得及給outcome賦值
// 這個時候讓出執(zhí)行權(quán)讓其他線程優(yōu)先執(zhí)行
else if (s == COMPLETING) // cannot time out yet
Thread.yield();
// 4. 如果等待節(jié)點為空，則構(gòu)造一個等待節(jié)點
else if (q == null)
q = new WaitNode();
// 5. 如果還沒有入隊列，則把當前節(jié)點加入waiters首節(jié)點并替換原來waiters
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);
// 如果需要等待特定時間，則先計算要等待的時間
// 如果已經(jīng)超時，則刪除對應(yīng)節(jié)點并返回對應(yīng)的狀態(tài)
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
else
LockSupport.park(this);
}
}
- awaitDone()中有個死循環(huán)，每一次循環(huán)都會判斷調(diào)用get()的線程是否被其他線程中斷，如果是的話則在等待隊列中刪除對應(yīng)節(jié)點然后拋出InterruptedException異常。
- 獲取任務(wù)當前狀態(tài)，如果當前任務(wù)狀態(tài)大于COMPLETING則表示任務(wù)執(zhí)行完成，則把thread字段置null并返回結(jié)果。
- 如果任務(wù)處于COMPLETING狀態(tài)，則表示任務(wù)已經(jīng)處理完成(正常執(zhí)行完成或者執(zhí)行出現(xiàn)異常)，但是執(zhí)行結(jié)果或者異常原因還沒有保存到outcome字段中。這個時候調(diào)用線程讓出執(zhí)行權(quán)讓其他線程優(yōu)先執(zhí)行。
- 如果等待節(jié)點為空，則構(gòu)造一個等待節(jié)點WaitNode。
- 如果第四步中新建的節(jié)點還沒如隊列，則CAS的把該節(jié)點加入waiters隊列的首節(jié)點。
- 阻塞等待。
假設(shè)當前state=NEW且waiters為NULL,也就是說還沒有任何一個線程調(diào)用get()獲取執(zhí)行結(jié)果，這個時候有兩個線程threadA和threadB先后調(diào)用get()來獲取執(zhí)行結(jié)果。再假設(shè)這兩個線程在加入阻塞隊列進行阻塞等待之前任務(wù)都沒有執(zhí)行完成且threadA和threadB都沒有被中斷的情況下(因為如果threadA和threadB在進行阻塞等待結(jié)果之前任務(wù)就執(zhí)行完成或線程本身被中斷的話，awaitDone()就執(zhí)行結(jié)束返回了)，執(zhí)行過程是這樣的，以threadA為例:
- 第一輪for循環(huán)，執(zhí)行的邏輯是q == null,所以這時候會新建一個節(jié)點q。第一輪循環(huán)結(jié)束。
- 第二輪for循環(huán)，執(zhí)行的邏輯是!queue，這個時候會把第一輪循環(huán)中生成的節(jié)點的netx指針指向waiters，然后CAS的把節(jié)點q替換waiters。也就是把新生成的節(jié)點添加到waiters鏈表的首節(jié)點。如果替換成功，queued=true。第二輪循環(huán)結(jié)束。
- 第三輪for循環(huán)，進行阻塞等待。要么阻塞特定時間，要么一直阻塞知道被其他線程喚醒。
在threadA和threadB都阻塞等待之后的waiters結(jié)果如圖
[圖片上傳失敗...(image-d8c828-1513762765353)]
cancel(boolean)
public boolean cancel(boolean mayInterruptIfRunning) {
//1.傳入 false 一般意思是 取消還沒開始的任務(wù)設(shè)置成CANCELLED
//2.傳入 true 一般意思是取消還沒開始的任務(wù)設(shè)置成INTERRUPTING
if (!(state == NEW &&// 1. 如果任務(wù)已經(jīng)結(jié)束，則直接返回false
UNSAFE.compareAndSwapInt(this, stateOffset, NEW,
mayInterruptIfRunning ? INTERRUPTING : CANCELLED)))
//還沒開始 設(shè)置CANCELLEN 開始了設(shè)置 失敗返回false
return false;
try { // in case call to interrupt throws exception
//2.傳入true
if (mayInterruptIfRunning) {
try {
Thread t = runner;
// 2.1 中斷任務(wù)執(zhí)行線程
if (t != null)
t.interrupt();
} finally { // final state
UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED);
}
}
} finally {
finishCompletion();
}
return true;
}
cancel()方法會做下面幾件事:
1 .判斷任務(wù)當前執(zhí)行狀態(tài)，如果任務(wù)狀態(tài)不為NEW，則說明任務(wù)或者已經(jīng)執(zhí)行完成，或者執(zhí)行異常，不能被取消，根據(jù)傳入的情況設(shè)置INTERRUPTING，或CANCELLED。
判斷需要中斷任務(wù)執(zhí)行線程，則
修改任務(wù)狀態(tài)為INTERRUPTED。這個轉(zhuǎn)換過程對應(yīng)上圖中的四。調(diào)用finishCompletion()。
finishCompletion()
根據(jù)前面的分析，不管是任務(wù)執(zhí)行異常還是任務(wù)正常執(zhí)行完畢，或者取消任務(wù)，最后都會調(diào)用finishCompletion()方法，該方法實現(xiàn)如下:
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
for (;;) {
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
}
這個方法的實現(xiàn)比較簡單，依次遍歷waiters鏈表，喚醒節(jié)點中的線程，然后把callable置空。
被喚醒的線程會各自從awaitDone()方法中的LockSupport.park*()阻塞中返回，然后會進行新一輪的循環(huán)。在新一輪的循環(huán)中會返回執(zhí)行結(jié)果(或者更確切的說是返回任務(wù)的狀態(tài))。
report()
report()方法用在get()方法中，作用是把不同的任務(wù)狀態(tài)映射成任務(wù)執(zhí)行結(jié)果。實現(xiàn)如下：
private V report(int s) throws ExecutionException {
Object x = outcome;
// 1. 任務(wù)正常執(zhí)行完成，返回任務(wù)執(zhí)行結(jié)果
if (s == NORMAL)
return (V)x;
// 2. 任務(wù)被取消，拋出CancellationException異常
if (s >= CANCELLED)
throw new CancellationException();
// 3. 其他狀態(tài)，拋出執(zhí)行異常ExecutionException
throw new ExecutionException((Throwable)x);
}
映射關(guān)系如下圖所示:
[圖片上傳失敗...(image-a3c07e-1513762765353)]
get(long,TimeUnit)
public V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
if (unit == null)
throw new NullPointerException();
int s = state;
if (s <= COMPLETING &&
// 如果awaitDone()超時返回之后任務(wù)還沒結(jié)束，則拋出異常
(s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
throw new TimeoutException();
return report(s);
}
跟get()不同點在于get(long,TimeUnit)會在awaitDone()超時返回之后拋出TimeoutException異常。
isCancelled()和isDone()
vpublic boolean isCancelled() {
return state >= CANCELLED;
}
public boolean isDone() {
return state != NEW;
}
根據(jù)前面的分析，這兩個方法就很容易理解不用多做解釋了。
總結(jié)下，其實FutureTask的實現(xiàn)還是比較簡單的，當用戶實現(xiàn)Callable()接口定義好任務(wù)之后，把任務(wù)交給其他線程進行執(zhí)行。FutureTask內(nèi)部維護一個任務(wù)狀態(tài)，任何操作都是圍繞著這個狀態(tài)進行，并隨時更新任務(wù)狀態(tài)。任務(wù)發(fā)起者調(diào)用get*()獲取執(zhí)行結(jié)果的時候，如果任務(wù)還沒有執(zhí)行完畢，則會把自己放入阻塞隊列中然后進行阻塞等待。當任務(wù)執(zhí)行完成之后，任務(wù)執(zhí)行線程會依次喚醒阻塞等待的線程。調(diào)用cancel()取消任務(wù)的時候也只是簡單的修改任務(wù)狀態(tài)，如果需要中斷任務(wù)執(zhí)行線程的話則調(diào)用Thread.interrupt()中斷任務(wù)執(zhí)行線程。
有個值得關(guān)注的問題就是當任務(wù)還在執(zhí)行的時候用戶調(diào)用cancel(true)方法能否真正讓任務(wù)停止執(zhí)行呢？
在前面的分析中我們直到，當調(diào)用cancel(true)方法的時候，實際執(zhí)行還是Thread.interrupt()方法，而interrupt()方法只是設(shè)置中斷標志位，如果被中斷的線程處于sleep()、wait()或者join()邏輯中則會拋出InterruptedException異常。
