Future系列文章
Future三重奏第一章:Future設計模式及代碼示例
Future三重奏第二章:FutureTask源碼解析
FutureTask是做什麼的
futureTask是一種可取消的異步任務,通過調用get()方法獲取異步執行的返回結果,如果異步任務還沒有完成,get()方法將會阻塞調用線程,將當前線程掛起,直到任務執行結束,將會喚醒被掛起的線程,完成整個調用過程
FutureTask是如何貫徹future模式的思想
在上一章節中,我們有幾個基礎類來共同實現了future設計模式,實際上這些過程在futureTask類的源碼中都幫我們做了
- Main類:發起請求,構建一個Client類並且返回一個date對象
- Client類:啓動一個線程,並且創建一個業務類,該業務類返回實際獲取的數據,在獲取實際數據後,Client創建futureData類通過set方法將返回數據保存進futureData對象中,並返回futureData對象
- RealData類:實際業務類
- FutureData類:實現得到數據和設置數據的中間類,裏面實現了set()方法和get()方法,set()方法將數據寫入並返回,get()方法獲取裝載的數據
如果要實現future模式,需要通過這些類來實現,但是futureTask的源碼中已經幫我們實現了這套繁雜的邏輯,下面通過源碼的解析來說下futureTask是如何做的
FutureTask源碼解析
futureTask使用方式
- FutureTask + Thread
EventOrderTask task=new EventOrderTask(eventId);//實際的業務實現類
FutureTask futureTask=new FutureTask(task);//將任務構建一個futureTask對象
Thread thread =new Thread(futureTask);//構建並啓動線程
thread.start();
- Future + ExecutorService
//step1 ......
//step2:創建計算任務
Task task = new Task();
//step3:創建線程池,將Callable類型的task提交給線程池執行,通過Future獲取子任務的執行結果
ExecutorService executorService = Executors.newCachedThreadPool();
final Future<Boolean> future = executorService.submit(task);
//step4:通過future獲取執行結果
boolean result = (boolean) future.get();
- FutureTask + ExecutorService
//step1 ......
//step2 ......
//step3:將FutureTask提交給線程池執行
ExecutorService executorService = Executors.newCachedThreadPool();
executorService.execute(futureTask);
//step4 ......
FutureTask源碼的基本構成
- FutureTask實現了RunnableFuture接口
- RunnableFuture繼承Runnable, Future接口,所以FutureTask是這兩個接口的實現類,具備future接口和runnable的特性,需要重寫callable接口
- 在變量的組成中state代表了當前任務的狀態的轉變:
- NEW -> COMPLETING -> NORMAL 初始化 -> 計算完成(還沒有將計算結果賦值給) -> 執行完成
- NEW -> COMPLETING -> EXCEPTIONAL 初始化 -> 計算完成(還沒有將計算結果賦值給) -> 拋出異常
- NEW -> CANCELLED 初始化 -> 取消任務
- NEW -> INTERRUPTING -> INTERRUPTED 初始化 -> 打斷
public class FutureTask<V> implements RunnableFuture<V> {
private volatile int state;
private static final int NEW = 0;//初始化時是NEW
private static final int COMPLETING = 1;//任務完成但是尚未賦值給outcome
private static final int NORMAL = 2;//任務完成且賦值給outcome
private static final int EXCEPTIONAL = 3;//異常狀態
private static final int CANCELLED = 4;//任務取消
private static final int INTERRUPTING = 5;//任務打斷
private static final int INTERRUPTED = 6;//
// The underlying callable; nulled out after running
// 是構造函數中傳入的計算數據的任務類,該類實現了Callable接口
private Callable<V> callable;
// The result to return or exception to throw from get()
// 實際數據值
private Object outcome; // non-volatile, protected by state reads/writes
// The thread running the callable; CASed during run()
// 運行callable的線程(實際計算的線程)
private volatile Thread runner;
//FutureTask的構造方法,傳入實現了callable的數據類,對callable進行賦值,在run方法中進行調用
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
}
解析future實現異步執行任務並獲取任務結果
在主函數中啓動線程,將會調用futureTask中的run方法啓動異步線程,調用數據類,並返回計算結果,將數據封裝進futureTask方法中
run方法的執行邏輯
構造futureTask對象的時候,構造函數中傳入實現了callable接口的任務類,該類重寫了call方法,在run方法中調用重寫的call方法並返回計算結果,如果數據獲取成功,調用set(result)方法將獲取到的數據賦值給outcome變量
public void run() {
//檢查當前future線程的任務執行狀態是否是可執行狀態,如果不是則直接返回
if (state != NEW ||
!UNSAFE.compareAndSwapObject(this, runnerOffset,
null, Thread.currentThread()))
return;
try {
Callable<V> c = callable; //獲取callable數據類
if (c != null && state == NEW) { //如果數據類不是null且狀態爲NEW
V result; //實際返回數據類
boolean ran;
try {
result = c.call(); //調用實際業務類重寫的call方法,獲取實際數據
ran = true; //將ran設置爲true
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result); //獲取到實際參數後調用set方法將數據存進futureTask中
}
} 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);
}
}
在這裏我們要重點看下set(result)這個進行賦值的操作
這個方法比較簡單,首先是找到當前state在內存中的地址,然後將state的狀態變成COMPLETING,注意的是state是volatile變量類型,所以多個子線程在運行的過程中看到的值都是同一個
當state狀態被改成COMPLETING成功後,則將異步任務的計算結果賦值給變量outcome,賦值成功後,將state更改成爲NORMAL
最後調用方法finishCompletion()喚醒等待返回結果的線程,釋放資源
protected void set(V v) {
if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
outcome = v;//將最終結果賦值給outcome
UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
finishCompletion();//
}
}
調用finishCompletion()的主要作用是喚醒所有等待鏈表中的等待節點,讓所有被掛起的線程可以繼續執行awaitDone方法
當waiters不爲空的時候,首先將其置爲null,然後在獲取內部的線程,將所有鏈表中的線程全部喚醒,在該方法中,喚醒的是該futureTask對象中的所有被掛起的子線程
private void finishCompletion() {
// assert state > COMPLETING;
//waiters不爲空的時候,waiters是封裝該futureTask對象的線程
for (WaitNode q; (q = waiters) != null;) {
//如果當前等待線程就是當前線程則置爲null
if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
//當前循環體喚醒了當前futureTask中所有等待隊列中的節點(掛起的線程),目的是什麼呢,被喚醒的線程做什麼呢
//被喚醒的線程繼續執行各自線程棧中的awaitDone方法,嘗試獲取對應的結果
for (;;) {
Thread t = q.thread;//獲取當前節點中的線程
if (t != null) {//如果線程不爲空
q.thread = null;//將等待節點的線程設置爲null
LockSupport.unpark(t);//喚醒等待節點中的線程
}
WaitNode next = q.next;//獲取等待節點的下一個節點
if (next == null)//如果等待隊列已經沒有等待節點了,則直接跳出當前循環
break;
q.next = null; // unlink to help gc
q = next; //將下一個等待節點賦值給q節點
}
break;
}
}
done();
callable = null; // to reduce footprint
}
至此,futureTask對象則完成了獲取任務,計算任務,並將任務進行賦值的過程,在上面的方法中,我們會將被掛起的線程進行喚醒操作,線程被掛起是因爲在計算結果沒出來之前,通過futureTask對象調用get()方法去獲取執行結果了,當執行線程發現結果還沒有出來,線程就會被掛起,代碼如下:
public V get() throws InterruptedException, ExecutionException {
int s = state;
if (s <= COMPLETING)
s = awaitDone(false, 0L); //p2-1:等待計算結果
return report(s);//返回實際數據
}
當有線程訪問get方法的時候,首先會去判斷當前任務狀態,如果任務還沒有執行完成,則會調用awaitDone對當前線程進行阻塞
private int awaitDone(boolean timed, long nanos)
throws InterruptedException {
final long deadline = timed ? System.nanoTime() + nanos : 0L;
WaitNode q = null;//阻塞隊列元素,被掛起的線程都會被封裝成爲該對象
boolean queued = false;
//1:如果一旦該線程被中斷了,將會移除阻塞隊列中的任務,因爲futureTask設計有取消任務的操作
//情景:任務還沒有被完成
for (;;) {
if (Thread.interrupted()) {
removeWaiter(q);
throw new InterruptedException();
}
int s = state;
if (s > COMPLETING) { //2:如果任務完成或是已經取消了
if (q != null) //如果隊列元素有值,則將隊列元素設置爲null,並返回當前線程任務的狀態
q.thread = null;
return s;
}
else if (s == COMPLETING) // 3:如果任務完成了(正常/異常)還沒有賦值給指定接受元素(不能超時)
Thread.yield(); //重新選擇可執行的線程,emmmmmm
else if (q == null) //4:如果等待節點爲空,則創建一個等待隊列元素
q = new WaitNode();
//5:如果這個節點還沒有加入到等待隊列中,則將這個節點加入到隊列的頭部
else if (!queued)
queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
q.next = waiters, q);//waiters是等待隊列的頭結點
//6:如果設置了超時時間等待,則在指定的時間內移除等待對壘
else if (timed) {
nanos = deadline - System.nanoTime();
if (nanos <= 0L) {
removeWaiter(q);
return state;
}
LockSupport.parkNanos(this, nanos);
}
//7:否則阻塞線程,等待喚醒
else
LockSupport.park(this);
}
}
代碼看起來很多,但其實簡單點分析主要做了三步
- 第一次循環,這時候s<COMPLETING,此時q==null,這時應該創建一個WaitNode對象,節點對象中的線程就是當前線程,繼續進行循環
- 第二次循環,進入方法5,將創建的q加入到鏈表首位置當中
- 第三次循環,是否設置了超時時間,然後將線程掛起
至此,就是整個futureTask完成異步任務的執行過程,值得注意的是,futureTask通過cas+volatile的方式,進行數據的同步和通知