徹底理解Java的feature模式
轉載自：點選開啟連結 注：通俗易懂，詳細無比！
先上一個場景：假如你突然想做飯，但是沒有廚具，也沒有食材。網上購買廚具比較方便，食材去超市買更放心。
實現分析：在快遞員送廚具的期間，我們肯定不會閒著，可以去超市買食材。所以，在主執行緒裡面另起一個子執行緒去網購廚具。
但是，子執行緒執行的結果是要返回廚具的，而run方法是沒有返回值的。所以，這才是難點，需要好好考慮一下。
模擬程式碼1：
package test; public class CommonCook { public static void main(String[] args) throwsInterruptedException { long startTime = System.currentTimeMillis(); // 第一步 網購廚具 OnlineShopping thread = new OnlineShopping(); thread.start(); thread.join(); // 保證廚具送到 // 第二步 去超市購買食材 Thread.sleep(2000); // 模擬購買食材時間 Shicai shicai = new Shicai(); System.out.println("第二步：食材到位"); // 第三步 用廚具烹飪食材 System.out.println("第三步：開始展現廚藝"); cook(thread.chuju, shicai); System.out.println("總共用時" + (System.currentTimeMillis() - startTime) + "ms"); } // 網購廚具執行緒 static class OnlineShopping extends Thread { privateChuju chuju; @Override public void run() { System.out.println("第一步：下單"); System.out.println("第一步：等待送貨"); try { Thread.sleep(5000); // 模擬送貨時間 } catch (InterruptedException e) { e.printStackTrace(); } System.out.println("第一步：快遞送到"); chuju = new Chuju(); } } // 用廚具烹飪食材 static void cook(Chuju chuju, Shicai shicai) {} // 廚具類 static class Chuju {} // 食材類 static class Shicai {} }
執行結果：
第一步：下單
第一步：等待送貨
第一步：快遞送到
第二步：食材到位
第三步：開始展現廚藝
總共用時7013ms
可以看到，多執行緒已經失去了意義。在廚具送到期間，我們不能幹任何事。對應程式碼，就是呼叫join方法阻塞主執行緒。
有人問了，不阻塞主執行緒行不行？？？
不行！！！
從程式碼來看的話，run方法不執行完，屬性chuju就沒有被賦值，還是null。換句話說，沒有廚具，怎麼做飯。
Java現在的多執行緒機制，核心方法run是沒有返回值的；如果要儲存run方法裡面的計算結果，必須等待run方法計算完，無論計算過程多麼耗時。
面對這種尷尬的處境，程式設計師就會想：在子執行緒run方法計算的期間，能不能在主執行緒裡面繼續非同步執行？？？
Where there is a will，there is a way！！！
這種想法的核心就是Future模式，下面先應用一下Java自己實現的Future模式。
模擬程式碼2：
package test; import java.util.concurrent.Callable; import java.util.concurrent.ExecutionException; import java.util.concurrent.FutureTask; public class FutureCook { public static void main(String[] args) throws InterruptedException, ExecutionException { long startTime = System.currentTimeMillis(); // 第一步 網購廚具 Callable<Chuju> onlineShopping = new Callable<Chuju>() { @Override public Chuju call() throws Exception { System.out.println("第一步：下單"); System.out.println("第一步：等待送貨"); Thread.sleep(5000); // 模擬送貨時間 System.out.println("第一步：快遞送到"); return new Chuju(); } }; FutureTask<Chuju> task = new FutureTask<Chuju>(onlineShopping); new Thread(task).start(); // 第二步 去超市購買食材 Thread.sleep(2000); // 模擬購買食材時間 Shicai shicai = new Shicai(); System.out.println("第二步：食材到位"); // 第三步 用廚具烹飪食材 if (!task.isDone()) { // 聯絡快遞員，詢問是否到貨 System.out.println("第三步：廚具還沒到，心情好就等著（心情不好就呼叫cancel方法取消訂單）"); } Chuju chuju = task.get(); System.out.println("第三步：廚具到位，開始展現廚藝"); cook(chuju, shicai); System.out.println("總共用時" + (System.currentTimeMillis() - startTime) + "ms"); } // 用廚具烹飪食材 static void cook(Chuju chuju, Shicai shicai) {} // 廚具類 static class Chuju {} // 食材類 static class Shicai {} }
執行結果：
第一步：下單
第一步：等待送貨
第二步：食材到位
第三步：廚具還沒到，心情好就等著（心情不好就呼叫cancel方法取消訂單）
第一步：快遞送到
第三步：廚具到位，開始展現廚藝
總共用時5005ms
可以看見，在快遞員送廚具的期間，我們沒有閒著，可以去買食材；而且我們知道廚具到沒到，甚至可以在廚具沒到的時候，取消訂單不要了。
好神奇，有沒有。
下面具體分析一下第二段程式碼：
1）把耗時的網購廚具邏輯，封裝到了一個Callable的call方法裡面。
public interface Callable<V> { /** * Computes a result, or throws an exception if unable to do so. * * @return computed result * @throws Exception if unable to compute a result */ V call() throws Exception; }
Callable介面可以看作是Runnable介面的補充，call方法帶有返回值，並且可以丟擲異常。
2）把Callable例項當作引數，生成一個FutureTask的物件，然後把這個物件當作一個Runnable，作為引數另起執行緒。
public class FutureTask<V> implements RunnableFuture<V>
public interface RunnableFuture<V> extends Runnable, Future<V>
public interface Future<V> { boolean cancel(boolean mayInterruptIfRunning); boolean isCancelled(); boolean isDone(); V get() throws InterruptedException, ExecutionException; V get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException; }
這個繼承體系中的核心介面是Future。Future的核心思想是：一個方法f，計算過程可能非常耗時，等待f返回，顯然不明智。可以在呼叫f的時候，立馬返回一個Future，可以通過Future這個資料結構去控制方法f的計算過程。
這裡的控制包括：
get方法：獲取計算結果（如果還沒計算完，也是必須等待的）
cancel方法：還沒計算完，可以取消計算過程
isDone方法：判斷是否計算完
isCancelled方法：判斷計算是否被取消
這些介面的設計很完美，FutureTask的實現註定不會簡單，後面再說。
3）在第三步裡面，呼叫了isDone方法檢視狀態，然後直接呼叫task.get方法獲取廚具，不過這時還沒送到，所以還是會等待3秒。對比第一段程式碼的執行結果，這裡我們節省了2秒。這是因為在快遞員送貨期間，我們去超市購買食材，這兩件事在同一時間段內非同步執行。
通過以上3步，我們就完成了對Java原生Future模式最基本的應用。下面具體分析下FutureTask的實現，先看JDK8的，再比較一下JDK6的實現。
既然FutureTask也是一個Runnable，那就看看它的run方法
public void run() { if (state != NEW || !UNSAFE.compareAndSwapObject(this, runnerOffset, null, Thread.currentThread())) return; try { Callable<V> c = callable; // 這裡的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); // 儲存call方法丟擲的異常 } if (ran) set(result); // 儲存call方法的執行結果 } } 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); } }
先看try語句塊裡面的邏輯，發現run方法的主要邏輯就是執行Callable的call方法，然後將儲存結果或者異常（用的一個屬性result）。這裡比較難想到的是，將call方法丟擲的異常也儲存起來了。
這裡表示狀態的屬性state是個什麼鬼
* Possible state transitions: * NEW -> COMPLETING -> NORMAL * NEW -> COMPLETING -> EXCEPTIONAL * NEW -> CANCELLED * NEW -> INTERRUPTING -> INTERRUPTED */ 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;
把FutureTask看作一個Future，那麼它的作用就是控制Callable的call方法的執行過程，在執行的過程中自然會有狀態的轉換：
1）一個FutureTask新建出來，state就是NEW狀態；COMPETING和INTERRUPTING用的進行時，表示瞬時狀態，存在時間極短(為什麼要設立這種狀態？？？不解)；NORMAL代表順利完成；EXCEPTIONAL代表執行過程出現異常；CANCELED代表執行過程被取消；INTERRUPTED被中斷
2）執行過程順利完成：NEW -> COMPLETING -> NORMAL
3）執行過程出現異常：NEW -> COMPLETING -> EXCEPTIONAL
4）執行過程被取消：NEW -> CANCELLED
5）執行過程中，執行緒中斷：NEW -> INTERRUPTING -> INTERRUPTED
程式碼中狀態判斷、CAS操作等細節，請讀者自己閱讀。
再看看get方法的實現：
public V get() throws InterruptedException, ExecutionException { int s = state; if (s <= 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) // 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); } }
get方法的邏輯很簡單，如果call方法的執行過程已完成，就把結果給出去；如果未完成，就將當前執行緒掛起等待。awaitDone方法裡面死迴圈的邏輯，推演幾遍就能弄懂；它裡面掛起執行緒的主要創新是定義了WaitNode類，來將多個等待執行緒組織成佇列，這是與JDK6的實現最大的不同。
掛起的執行緒何時被喚醒：
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 }
以上就是JDK8的大體實現邏輯，像cancel、set等方法，也請讀者自己閱讀。
再來看看JDK6的實現。
JDK6的FutureTask的基本操作都是通過自己的內部類Sync來實現的，而Sync繼承自AbstractQueuedSynchronizer這個出鏡率極高的併發工具類
/** State value representing that task is running */ private static final int RUNNING = 1; /** State value representing that task ran */ private static final int RAN = 2; /** State value representing that task was cancelled */ private static final int CANCELLED = 4; /** The underlying callable */ private final Callable<V> callable; /** The result to return from get() */ private V result; /** The exception to throw from get() */ private Throwable exception;
裡面的狀態只有基本的幾個，而且計算結果和異常是分開儲存的。
V innerGet() throws InterruptedException, ExecutionException { acquireSharedInterruptibly(0); if (getState() == CANCELLED) throw new CancellationException(); if (exception != null) throw new ExecutionException(exception); return result; }
這個get方法裡面處理等待執行緒佇列的方式是呼叫了acquireSharedInterruptibly方法，看過我之前幾篇部落格文章的讀者應該非常熟悉了。其中的等待執行緒佇列、執行緒掛起和喚醒等邏輯，這裡不再贅述，如果不明白，請出門左轉。