多線程中Future模式的詳細介紹

本篇內容介紹了“多線程中Future模式的詳細介紹”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

在高性能編程中，并發編程已經成為了極為重要的一部分。在單核CPU性能已經趨于極限時，我們只能通過多核來進一步提升系統的性能，因此就催生了并發編程。

由于并發編程比串行編程更困難，也更容易出錯，因此，我們就更需要借鑒一些前人優秀的，成熟的設計模式，使得我們的設計更加健壯，更加完美。

而Future模式，正是其中使用最為廣泛，也是極為重要的一種設計模式。今天就跟阿丙了解一手Future模式!

生活中的Future模式

為了更快的了解Future模式，我們先來看一個生活中的例子。

場景1：

午飯時間到了，同學們要去吃飯了，小王下樓，走了20分鐘，來到了肯德基，點餐，排隊，吃飯一共花了20分鐘，又花了20分鐘走回公司繼續工作，合計1小時。

場景2

午飯時間到了，同學們要去吃飯了，小王點了個肯德基外賣，很快，它就拿到了一個訂單(雖然訂單不能當飯吃，但是有了訂單，還怕吃不上飯嘛)。接著小王可以繼續干活，30分鐘后，外賣到了，接著小王花了10分鐘吃飯，接著又可以繼續工作了，成功的卷到了隔壁的小汪。

很明顯，在這2個場景中，小王的工作時間更加緊湊，特別是那些排隊的時間都可以讓外賣員去干，因此可以更加專注于自己的本職工作。聰明的你應該也已經體會到了，場景1就是典型的函數同步調用，而場景2是典型的異步調用。

而場景2的異步調用，還有一個特點，就是它擁有一個返回值，這個返回值就是我們的訂單。這個訂單很重要，憑借著這個訂單，我們才能夠取得當前這個調用所對應的結果。

這里的訂單就如同Future模式中的Future，這是一個合約，一份承諾。雖然訂單不能吃，但是手握訂單，不怕沒吃的，雖然Future不是我們想要的結果，但是拿著Future就能在將來得到我們想要的結果。

因此，Future模式很好的解決了那些需要返回值的異步調用。

Future模式中的主要角色

一個典型的Future模式由以下幾個部分組成：

• Main：系統啟動，調用Client發出請求

• Client：返回Data對象，立即返回FutureData，并開啟ClientThread線程裝配RealData

• Data：返回數據的接口

• FutureData：Future數據，構造很快，但是是一個虛擬的數據，需要裝配RealData，好比一個訂單

• RealData：真實數據，其構造是比較慢的，好比上面例子中的肯德基午餐。

它們之間的相互關系如下圖：

其中，值得注意是Data，RealData和FutureData。這是一組典型的代理模式，Data接口表示對外數據，RealData表示真實的數據，就好比午餐，獲得它的成本比較高，需要很多時間;相對的FutureData作為RealData的代理，類似于一個訂單/契約，通過FutureData，可以在將來獲得RealData。

因此，Future模式本質上是代理模式的一種實際應用。

實現一個簡單的Future模式

根據上面的設計，讓我們來實現一個簡單的代理模式吧!

首先是Data接口，代表數據：

public interface Data {     public String getResult (); }

接著是FutureData，也是整個Future模式的核心：

public class FutureData implements Data {     // 內部需要維護RealData     protected RealData realdata = null;               protected boolean isReady = false;     public synchronized void setRealData(RealData realdata) {         if (isReady) {              return;         }         this.realdata = realdata;         isReady = true;         //RealData已經被注入，通知getResult()         notifyAll();                                    }     //會等待RealData構造完成     public synchronized String getResult() {                  while (!isReady) {             try {                 //一直等待，直到RealData被注入                 wait();                                        } catch (InterruptedException e) {             }         }         //真正需要的數據從RealData獲取         return realdata.result;                           } }

下面是RealData：

public class RealData implements Data {     protected final String result;     public RealData(String para) {         StringBuffer sb=new StringBuffer();         //假設這里很慢很慢，構造RealData不是一個容易的事         result =sb.toString();     }     public String getResult() {         return result;     } }

然后從Client得到Data：

public class Client {     //這是一個異步方法，返回的Data接口是一個Future     public Data request(final String queryStr) {         final FutureData future = new FutureData();         new Thread() {                                                   public void run() {                                      // RealData的構建很慢，所以在單獨的線程中進行                 RealData realdata = new RealData(queryStr);                 //setRealData()的時候會notify()等待在這個future上的對象                 future.setRealData(realdata);             }                                                        }.start();         // FutureData會被立即返回，不會等待RealData被構造完         return future;                               } }

最后一個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);     } catch (InterruptedException e) {     }     //使用真實的數據，如果到這里數據還沒有準備好，getResult()會等待數據準備完，再返回     System.out.println("數據 = " + data.getResult()); }

這是一個最簡單的Future模式的實現，雖然簡單，但是已經包含了Future模式中最精髓的部分。對大家理解JDK內部的Future對象，有著非常重要的作用。

Java中的Future模式

Future模式是如此常用，在JDK內部已經有了比較全面的實現和支持。下面，讓我們一起看看JDK內部的Future實現：

首先，JDK內部有一個Future接口，這就是類似前面提到的訂單，當然了，作為一個完整的商業化產品，這里的Future的功能更加豐富了，除了get()方法來獲得真實數據以外，還提供一組輔助方法，比如：

• cancel()：如果等太久，你可以直接取消這個任務

• isCancelled()：任務是不是已經取消了

• isDone()：任務是不是已經完成了

• get()：有2個get()方法，不帶參數的表示無窮等待，或者你可以只等待給定時間

下面代碼演示了這個Future的使用方法：

//異步操作 可以用一個線程池   ExecutorService executor = Executors.newFixedThreadPool(1);   //執行FutureTask，相當于上例中的 client.request("name") 發送請求   //在這里開啟線程進行RealData的call()執行   Future<String> future = executor.submit(new RealData("name"));   System.out.println("請求完畢，數據準備中");   try {       //這里依然可以做額外的數據操作，這里使用sleep代替其他業務邏輯的處理       Thread.sleep(2000);   } catch (InterruptedException e) {   }   //如果此時call()方法沒有執行完成，則依然會等待   System.out.println("數據 = " + future.get());

整個使用過程非常簡單，下面我們來分析一下executor.submit()里面究竟發生了什么：

public <T> Future<T> submit(Callable<T> task) {     if (task == null) throw new NullPointerException();     // 根據Callable對象，創建一個RunnableFuture，這里其實就是FutureTask     RunnableFuture<T> ftask = newTaskFor(task);     //將ftask推送到線程池     //在新線程中執行的，就是run()方法，在下面的代碼中有給出     execute(ftask);     //返回這個Future，將來通過這個Future就可以得到執行的結果     return ftask; } protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {     return new FutureTask<T>(callable); }

最關鍵的部分在下面，FutureTask作為一個線程單獨執行時，會將結果保存到outcome中，并設置任務的狀態,下面是FutureTask的run()方法：

從FutureTask中獲得結果的實現如下：

public V get() throws InterruptedException, ExecutionException {        int s = state;        //如果沒有完成，就等待，回到用park()方法阻塞線程        //同時，所有等待線程會在FutureTask的waiters字段中排隊等待        if (s <= COMPLETING)            s = awaitDone(false, 0L);        return report(s);    }    private V report(int s) throws ExecutionException {        //outcome里保存的就是最終的計算結果        Object x = outcome;        if (s == NORMAL)            //正常完成，就返回outcome            return (V)x;        //如果沒有正常完成， 比如被用戶取消了，或者有異常了，就拋出異常        if (s >= CANCELLED)            throw new CancellationException();        throw new ExecutionException((Throwable)x);    }

Future模式的高階版本—— CompletableFuture

Future模式雖然好用，但也有一個問題，那就是將任務提交給線程后，調用線程并不知道這個任務什么時候執行完，如果執行調用get()方法或者isDone()方法判斷，可能會進行不必要的等待，那么系統的吞吐量很難提高。

為了解決這個問題，JDK對Future模式又進行了加強，創建了一個CompletableFuture，它可以理解為Future模式的升級版本，它最大的作用是提供了一個回調機制，可以在任務完成后，自動回調一些后續的處理，這樣，整個程序可以把“結果等待”完全給移除了。

下面來看一個簡單的例子：

在這個例子中，首先以getPrice()為基礎創建一個異步調用，接著，使用thenAccept()方法，設置了一個后續的操作，也就是當getPrice()執行完成后的后續處理。

不難看到，CompletableFuture比一般的Future更具有實用性，因為它可以在Future執行成功后，自動回調進行下一步的操作，因此整個程序不會有任何阻塞的地方(也就是說你不用去到處等待Future的執行，而是讓Future執行成功后，自動來告訴你)。

以上面的代碼為例，CompletableFuture之所有會有那么神奇的功能，完全得益于AsyncSupply類(由上述代碼中的supplyAsync()方法創建)。

AsyncSupply在執行時，如下所示：

public void run() {             CompletableFuture<T> d; Supplier<T> f;             if ((d = dep) != null && (f = fn) != null) {                 dep = null; fn = null;                 if (d.result == null) {                     try {                         //這里就是你要執行的異步方法                         //結果會被保存下來，放到d.result字段中                         d.completeValue(f.get());                     } catch (Throwable ex) {                         d.completeThrowable(ex);                     }                 }                 //執行成功了，進行后續處理，在這個后續處理中，就會調用thenAccept()中的消費者                 //這里就相當于Future完成后的通知                 d.postComplete();             }         }

繼續看d.postComplete()，這里會調用后續一系列操作

final void postComplete() {              //省略部分代碼，重點在tryFire()里              //在tryFire()里，真正觸發了后續的調用，也就是thenAccept()中的部分              f = (d = h.tryFire(NESTED)) == null ? this : d;          }      }  }

絮叨

今天，我們主要介紹Future模式，我們從一個最簡單的Future模式開始，逐步深入，先后介紹了JDK內部的Future模式實現，以及對Future模式的進化版本CompletableFuture做了簡單的介紹。對

于多線程開發而言，Future模式的應用極其廣泛，可以說這個模式已經成為了異步開發的基礎設施。

“多線程中Future模式的詳細介紹”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！