一、Futrue模式

客戶端發送一個長時間的請求，服務端不需等待該數據處理完成便立即返回一個偽造的代理數據（相當於商品訂單，不是商品本身），用戶也無需等待，先去執行其他的若幹操作後，再去調用服務器已經完成組裝的真實數據。

該模型充分利用了等待的時間片段。簡單來說就是，如果線程A要等待線程B的結果，那麽線程A沒必要等待B，直到B有結果，可以先拿到一個未來的Future，等B有結果是再取真實的結果。

在多線程中經常舉的一個例子就是：網絡圖片的下載，剛開始是通過模糊的圖片來代替最後的圖片，等下載圖片的線程下載完圖片後在替換。而在這個過程中可以做一些其他的事情。

二、Future模式的代碼實現

1、創建公共數據接口

 1 package com.ietree.basicskill.mutilthread.designpattern;
 2 
 3 /**
 4  * Created by Root on 5/12/2017.
 5  */
 6 public interface Data {
 7 
 8     String getRequest();
 9 
10 }

2、創建FutureData對象，當有程序想要獲取RealData的時候，程序會被阻塞，等到RealData被註入才會使用getReal()方法

 1 package com.ietree.basicskill.mutilthread.designpattern;
 
 2 
 3 /**
 4  * Created by Root on 5/12/2017.
 5  */
 6 public class FutureData implements Data {
 7 
 8     private RealData realData;
 9 
10     private boolean isReady = false;
11 
12     public synchronized void setRealData(RealData realData) {
13         // 如果已經裝載完畢了，就直接返回
14         if (isReady) {
15
 
             return;
16         }
17         // 如果沒裝載，進行裝載真實對象
18         this.realData = realData;
19         isReady = true;
20         // 進行通知
21         notify();
22     }
23 
24     @Override
25     public synchronized String getRequest() {
26         // 如果沒裝載好，程序就一直處於阻塞狀態
27         while (!isReady) {
28             try {
29                 wait();
30             } catch (InterruptedException e) {
31                 e.printStackTrace();
32             }
33         }
34         // 裝載好了直接獲取數據即可
35         return this.realData.getRequest();
36     }
37 }

3、真實數據RealData類

 1 package com.ietree.basicskill.mutilthread.designpattern;
 2 
 3 /**
 4  * Created by Root on 5/12/2017.
 5  */
 6 public class RealData implements Data {
 7 
 8     private String result;
 9 
10     public RealData(String queryStr) {
11         System.out.println("根據" + queryStr + "進行查詢，這是一個很耗時間的操作......");
12         try {
13             Thread.sleep(5000);
14         } catch (InterruptedException e) {
15             e.printStackTrace();
16         }
17         System.out.println("操作完畢，獲取結果");
18         result = "查詢結果";
19     }
20 
21     @Override
22     public String getRequest() {
23         return result;
24     }
25 }

4、客戶端代理類

 1 package com.ietree.basicskill.mutilthread.designpattern;
 2 
 3 /**
 4  * Created by Root on 5/12/2017.
 5  */
 6 public class FutureClient {
 7 
 8     public Data request(final String queryStr) {
 9         //1 我想要一個代理對象（Data接口的實現類）先返回給發送請求的客戶端，告訴他請求已經接收到，可以做其他的事情
10         final FutureData futureData = new FutureData();
11         //2 啟動一個新的線程，去加載真實的數據，傳遞給這個代理對象
12         new Thread(new Runnable() {
13             @Override
14             public void run() {
15                 //3 這個新的線程可以去慢慢的加載真實對象，然後傳遞給代理對象
16                 RealData realData = new RealData(queryStr);
17                 futureData.setRealData(realData);
18             }
19         }).start();
20 
21         return futureData;
22     }
23 
24 }

5、測試調用

 1 package com.ietree.basicskill.mutilthread.designpattern;
 2 
 3 /**
 4  * Created by Root on 5/12/2017.
 5  */
 6 public class FutureTest {
 7 
 8     public static void main(String[] args) {
 9         FutureClient fc = new FutureClient();
10         Data data = fc.request("請求參數");
11         System.out.println("請求發送成功！");
12 
13         try {
14             //處理其他業務
15             //這個過程中，真實數據RealData組裝完成，重復利用等待時間
16             System.out.println("做其它的事情......");
17             Thread.sleep(2000);
18         } catch (InterruptedException e) {
19             e.printStackTrace();
20         }
21 
22         // 獲取真實數據
23         String result = data.getRequest();
24         System.out.println(result);
25     }
26 
27 }

程序運行結果：

請求發送成功！
做其它的事情......
根據請求參數進行查詢，這是一個很耗時間的操作......
操作完畢，獲取結果
查詢結果

第二種寫法（沒有實際運用過）：

 1 package com.ietree.basicskill.mutilthread.designpattern;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 import java.util.concurrent.Callable;
 6 import java.util.concurrent.ExecutionException;
 7 import java.util.concurrent.ExecutorService;
 8 import java.util.concurrent.Executors;
 9 import java.util.concurrent.Future;
10 
11 /**
12  * Created by Root on 5/12/2017.
13  */
14 public class FutureTest2 {
15 
16     private static class Task implements Callable<String> {
17         @Override
18         public String call() throws Exception {
19             // 模擬真實事務的處理過程，這個過程是非常耗時的。
20             Thread.sleep(5000);
21             return "call return ";
22         }
23     }
24 
25     public static void main(String[] args) throws InterruptedException, ExecutionException {
26         
27         List<Future<String>> futures = new ArrayList<Future<String>>();
28         ExecutorService executorService = Executors.newCachedThreadPool();
29 
30         System.out.println("已經提交資源申請");
31         for (int i = 0; i < 10; i++) {
32             futures.add(executorService.submit(new Task()));
33         }
34 
35         for (Future<String> future : futures) {
36             // 判斷資源是不是已經準備完畢，準備完畢直接獲取。
37             if (!future.isDone()) {
38                 System.out.println("資源還沒有準備好");
39             }
40             System.out.println(future.get());
41         }
42         executorService.shutdown();
43     }
44 }

利用多線程實現Future模式