徹底理解Future模式

来源:https://www.cnblogs.com/eternityz/archive/2020/01/28/12238848.html
-Advertisement-
Play Games

先上一個場景：假如你突然想做飯，但是沒有廚具，也沒有食材。網上購買廚具比較方便，食材去超市買更放心。 實現分析：在快遞員送廚具的期間，我們肯定不會閑著，可以去超市買食材。所以，在主線程裡面另起一個子線程去網購廚具。 但是，子線程執行的結果是要返回廚具的，而run方法是沒有返回值的。所以，這才是難點， ...


先上一個場景：假如你突然想做飯，但是沒有廚具，也沒有食材。網上購買廚具比較方便，食材去超市買更放心。

實現分析：在快遞員送廚具的期間，我們肯定不會閑著，可以去超市買食材。所以，在主線程裡面另起一個子線程去網購廚具。

但是，子線程執行的結果是要返回廚具的，而run方法是沒有返回值的。所以，這才是難點，需要好好考慮一下。

模擬代碼1：

package test;

public class CommonCook {

    public static void main(String[] args) throws InterruptedException {
        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 {
        
        private Chuju 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方法.

當時做記錄的時候忘記記錄原文鏈接了,作者看到之後可以私信我,我補上原文鏈接.


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 解決浮點運算精度不准確,BigDecimal 加減乘除
    ``` package com.kflh.boxApi.utils.util; import java.math.BigDecimal; /** * @program: BoxApi * @description: 計算浮點數 * @author: eterntiyz * @create: 2019... ...
  • 阿裡fastjson解析
    解析案例 參考 fastJson對於json格式字元串的解析主要用到了一下三個類： JSON：fastJson的解析器，用於JSON格式字元串與JSON對象及javaBean之間的轉換。 JSONObject：fastJson提供的json對象。 JSONArray：fastJson提供json數組 ...
  • java可變參數
    可變參數 可變參數的特點： 那麼可不可以使用多個可變參數作為入參呢？答案是不可以的，原因跟上一個錯誤差不多，這種可變參數需要放到最後一個入參，多個可變參數，不可能都最為最後一個入參。相較於String[]這種形式的入參，我理解的優勢大概就是可以多個String傳入，也可以Sting[]傳入，就是te ...
  • set集合迭代
    1.迭代遍歷 2.for迴圈遍歷： 3.優點還體現在泛型 假如 set中存放的是Object ...
  • 包裝類型間的相等判斷
    ``` 包裝類型間的相等判斷應該用equals，而不是'!=' Inspection info: 所有的包裝類對象之間值的比較，全部使用equals方法比較。 說明：對於Integer var=?在-128至127之間的賦值，Integer對象是在IntegerCache.cache產生，會復用已有... ...
  • java集合與數組之間轉換
    數組轉換為集合 採用java中集合自帶的asList()方法就可以完成轉換了 特別註意: == 因為，Arrays.asList()方法轉換成的List集合類是java.util.Arrays.ArrayList下麵的，它是java.util.Arrays類中自己定義的一個內部類，沒有實現具體的ad ...
  • Java遍歷Map對象的四種方式
    關於java中遍歷map具體哪四種方式，請看下文詳解吧。 方式一 這是最常見的並且在大多數情況下也是最可取的遍歷方式。在鍵值都需要時使用。 方法二 在for each迴圈中遍歷keys或values。 如果只需要map中的鍵或者值，你可以通過keySet或values來實現遍歷，而不是用entryS ...
  • 小程式輪播圖總結
    wxml內容： <view class="container"> <navigator class="search"> <icon type="search" size="13"></icon>搜索 </navigator> <view class="banner_box"> <swiper cla ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類