並行設計模式（一）-- Future模式

　　Java多線程編程中，經常使用的多線程設計模式包括：Future模式、Master-Worker模式、Guarded Suspeionsion模式、不變模式和生產者-消費者模式等。這篇文章主要講述Future模式，關於其餘多線程設計模式的地址以下：
　　關於Master-Worker模式的詳解： 並行設計模式（二）-- Master-Worker模式
　　關於Guarded Suspeionsion模式的詳解： 並行設計模式（三）-- Guarded Suspeionsion模式
　　關於不變模式的詳解： 並行設計模式（四）-- 不變模式
　　關於生產者-消費者模式的詳解：並行設計模式（五）-- 生產者-消費者模式

1. Future模式

　　Future模式的核心在於：去除了主函數的等待時間，並使得本來須要等待的時間段能夠用於處理其餘業務邏輯。

　　Future模式有點相似於商品訂單。在網上購物時，提交訂單後，在收貨的這段時間裏無需一直在家裏等候，能夠先幹別的事情。類推到程序設計中時，當提交請求時，指望獲得答覆時，若是這個答覆可能很慢。傳統的是一直持續等待直到這個答覆收到以後再去作別的事情，但若是利用Future模式，其調用方式改成異步，而原先等待返回的時間段，在主調用函數中，則能夠用於處理其餘事務。

　　例如以下的請求調用過程時序圖。當call請求發出時，須要很長的時間才能返回。左邊的圖須要一直等待，等返回數據後才能繼續其餘操做；而右邊的Future模式的圖中客戶端則無需等到能夠作其餘的事情。服務器段接收到請求後當即返回結果給客戶端，這個結果並非真實的結果（是虛擬的結果），也就是先得到一個假數據，而後執行其餘操做。

 

　　Future模式的主要參與者以下表所示：

參 與 者	做  用
Main	系統啓動，調用Client發出請求
Client	返回Data對象，當即返回FutureData，並開啓ClientThread線程裝配RealData
Data	返回數據的接口
FutureData	Future數據，構造很快，可是是一個虛擬的數據，須要裝配RealData
RealData	真實數據，其構造是比較慢的

2. Future模式的代碼實現

應用實例對應模式結構圖以下所示：

　　　　

<1. Main函數的實現

　　Main函數主要負責調用Client發起請求，並使用返回的數據：

public class Main { public static void main(String[] args) { Client client = new Client(); // 這裏會當即返回，由於獲取的是FutureData，而非RealData Data data = client.request("name"); System.out.println("請求完畢"); try { // 這裏能夠用一個sleep代替對其餘業務邏輯的處理 // 在處理這些業務邏輯過程當中，RealData也正在建立，從而充分了利用等待時間 Thread.sleep(2000); // 使用真實數據 System.out.println("數據=" + data.getResult()); } catch (InterruptedException e) { e.printStackTrace(); } } }

<2. Client的實現

　　Client主要實現了獲取futrueData，開啓構造RealData的線程，並在接受請求後，很快地返回FutureData

public class Client { public Data request(final String string) { final FutureData futureData = new FutureData(); new Thread(new Runnable() { @Override public void run() { // RealData的構建很慢，因此放在單獨的線程中運行 RealData realData = new RealData(string); futureData.setRealData(realData); } }).start(); return futureData; // 先直接返回FutureData  } }

<3. Data的實現

　　Data是一個接口，提供了getResult()方法。不管futureData或者RealData都實現了這個接口

public interface Data { String getResult() throws InterruptedException; }

<4. FutureData的實現

　　FutureData實現了一個快速返回的RealData包裝。它只是一個包裝，或者說是一個RealData的虛擬實現。所以，它能夠很快被構造並返回。當使用FutureData的getResult()方法是，程序會阻塞，等待RealData被注入到程序中，才使用RealData的getResult()方法返回。

 1 public class FutureData implements Data {  2 RealData realData = null; // FutureData是RealData的封裝  3 boolean isReady = false; // 是否已經準備好  4  5 public synchronized void setRealData(RealData realData) {  6 if (isReady)  7 return;  8 this.realData = realData;  9 isReady = true; 10 notifyAll(); // RealData已經被注入到FutureData中了，通知getResult()方法 11  } 12 13  @Override 14 public String getResult() throws InterruptedException { 15 if (!isReady) { 16 wait(); // 一直等到RealData注入到FutureData中 17  } 18 return realData.getResult(); 19  } 20 }

<5. RealData的實現

　　RealData是最終須要使用的數據模型，它的構造很慢。在這裏，使用sleep()函數模擬這個過程

public class RealData implements Data { protected String data; public RealData(String data) { // 利用sleep方法來表示RealData構造過程是很是緩慢的 try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } this.data = data; } @Override public String getResult() throws InterruptedException { return data; } }

3. JDK的內置Future模式實現

　　因爲Future是很是經常使用的多線程設計模式，所以在JDK中內置了Future模式的實現。這些類在java.util.concurrent包裏面。其中最爲重要的是FutureTask類，它實現了Runnable接口，做爲單獨的線程運行。在其run()方法中，經過Sync內部類調用Callable接口，並維護Callable接口的返回對象。當使用FutureTask.get()方法時，將返回Callable接口的返回對象。其核心結構圖以下所示：

　　　　

　　JDK內置的Future模式功能強大，除了基本的功能外，它還能夠取消Future任務，或者設定future任務的超時時間。Callable接口是一個用戶自定義的實現。在應用程序中，經過實現Callable接口的call()方法，指定FutureTask的實際工做內容和返回對象。

　　Future接口提供的線程控制功能有：

1 boolean cancle(boolean mayInterruptIfRunning); // 取消任務 2 boolean isCancelled();　　// 是否已經取消 3 boolean isDone();　　　　// 是否已經完成 4 V get() throws InterruptedException, ExecutionException;　　//取得返回對象 5 V get(long timeout, TimeUnit unit);　　//取得返回對象，能夠設置超時時間

　　一樣，針對上述的實例，若是使用JDK自帶的實現，則須要做一些調整。

　　首先，須要實現Callable接口，實現具體的業務邏輯。在本例中，依然使用RealData來實現這個接口：

 1 public class RealData implements Callable<String> {  2 private String para;  3  4 public RealData(String para) {  5 this.para = para;  6  }  7  8  @Override  9 public String call() throws Exception { 10 // 利用sleep方法來表示真是業務是很是緩慢的 11 StringBuffer sb = new StringBuffer(); 12 for (int i = 0; i < 10; i++) { 13  sb.append(para); 14 try { 15 Thread.sleep(1000); 16 } catch (InterruptedException e) { 17  e.printStackTrace(); 18  } 19  } 20 return sb.toString(); 21  } 22 }

　　在這個改進中，RealData的構造變更很是快，由於其主要業務邏輯被移動到call()方法內，並經過call()方法返回。

　　Main方法修改以下，因爲使用了JDK的內置框架，Data、FutureData等對象就再也不須要了。在Main方法的實現中，直接經過RealData構造FutureTask，並將其做爲單獨的線程運行。在提交請求後，執行其餘業務邏輯，最後經過FutureTask.get()方法，獲得RealData的執行結果。

 1 public class Main {  2 public static void main(String[] args) {  3 FutureTask<String> future = new FutureTask<String>(new RealData("liangyongxing"));  4 ExecutorService executor = Executors.newFixedThreadPool(1); // 使用線程池  5 //執行FutureTask，至關於上例中的client.request("name")發送請求  6 //在這裏開啓線程進行RealData的call()執行  7  executor.submit(future);  8 System.out.println("請求完畢");  9 10 try { 11 // 這裏仍然能夠作額外的數據操做，這裏使用sleep代替其餘業務邏輯的處理 12 Thread.sleep(2000); 13 14 /** 15  * 至關於上例當中的 data.getResult()，取得call()方法的返回值 16  * 若是此時call()方法沒有執行完畢，則依然會等待 17 */ 18 System.out.println("數據 = " + future.get()); 19 } catch (InterruptedException | ExecutionException e) { 20  e.printStackTrace(); 21  } finally {
            　　executor.shutdown();
        　　} 22  } 23 }