您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 程式開發 >> iOS 開發基礎

Android 與 iOS 異步處理(四):異步任務與任務隊列

編輯:iOS 開發基礎

本文是系列文章《Android 和 iOS 開發中的異步處理》的第四篇,主要探討客戶端編程中經常使用的隊列結構、它的異步編程方式,以及相關的接口設計問題。

前幾天有位同事來找我討論一個問題。他在開發一款手遊,用戶在客戶端的每次操作都要向服務器同步數據。按傳統的網絡請求方式,用戶發起操作後得等待完成,期間界面要轉菊花;請求返回後才更新展示層,用戶才能進行下一步。但這款遊戲要求用戶能在短時間內連續做很多操作,若每步都經歷一次等待,體驗會非常糟糕。

其實這裡就需要一個操作任務隊列:用戶不必等待上一步完成,把操作丟進隊列就能繼續下一步;當隊列中有操作出錯時,進入統一的錯誤處理流程。當然,服務器也要配合,比如更慎重地對待操作去重。

本文要討論的,正是與隊列設計和實現相關的這些問題。

註:本系列代碼已整理到 GitHub(持續更新),地址為 https://github.com/tielei/AsyncProgrammingDemos 。本文的 Java 代碼位於 com.zhangtielei.demos.async.programming.queueing 這個 package 中。

概述

客戶端編程裡,用到隊列的場景其實不少,這裡列舉幾例:

  • 發送聊天消息:現在大多聊天軟件都允許連續輸入多條消息,用戶不必等前一條發送成功再敲下一條。系統保證消息有序,網絡不佳導致失敗的消息會重試若干次,盡力送達。這背後就是一個負責排隊與有限重試的消息發送隊列。

  • 一次上傳多張照片:批量上傳耗時較長,通常需要一個或多個隊列,配合重試還能實現斷點續傳(需服務端支持)。

  • 把高頻關鍵操作異步化以提陞體驗:比如前面說的手遊連續操作,再比如發朋友圈、評論,都不用等本次網絡請求結束即可繼續。這背後也藏着一個隊列機制。

為方便討論,我們把這種對一系列操作排隊、並具備一定失敗重試能力的隊列,稱為「任務隊列」。下文分三節展開:先介紹傳統的線程安全隊列 TSQ,再講適合客戶端的無鎖隊列(採用經典 Callback 回調方式設計接口),最後是基于 RxJava 響應式思想實現的隊列。

Thread-Safe Queue

多線程環境下談隊列,繞不開 TSQ。它是個經典工具,在不同線程間提供了一條有序傳輸數據的通道。

生產者與消費者分屬不同線程,才能解耦,生產不被消費阻塞。若把 TSQ 用作任務隊列,生產相當於用戶操作產生任務,消費相當於任務的啟動與執行。消費者線程運行在一個循環裡,不停嘗試取數據,沒數據就阻塞在隊列頭上,這種阻塞依賴操作系統原語。

用隊列解耦是一個很重要的思想。往遠了說,TSQ 推廣到進程之間,就近似於分布式系統裡常用的 Message Queue,對異構服務解耦、屏蔽服務間性能差異能起到關鍵作用。

TSQ 在客戶端卻比較少見,原因有二:

  • 它需要額外起一個獨立線程作消費者。
  • 更適合客戶端的「主線程 → 異步線程 → 主線程」模式(見系列第一篇 Run Loop 相關章節),使生產者與消費者都能跑在主線程,這樣只需普通隊列即可,不必線程安全(見下節)。

這裡提到 TSQ,主要是因其經典、便於對比。演示代碼用了 JDK 現成的實現:LinkedBlockingQueue。

基於 Callback 的任務隊列

如上圖,生產者與消費者都在同一個線程(主線程)。按此思路,我們要執行的任務本身必須是異步的,否則整個隊列無法異步化。異步任務接口定義如下:

public interface Task {
    /** 唯一標識當前任務的 ID */
    String getTaskId();

    /** start 只是啟動任務,完成後回調 TaskListener。注意:需在主線程執行。 */
    void start();

    /** 設置回調監聽 */
    void setListener(TaskListener listener);

    /** 異步任務回調接口 */
    interface TaskListener {
        void taskComplete(Task task);
        void taskFailed(Task task, Throwable cause);
    }
}

由於 Task 是異步的,我們為它定義了回調接口 TaskListener。getTaskId 用於精確區分不同任務;失敗原因這裡用一個 Throwable 對象表達(註:實際編程中未必值得效仿,需具體分析)。有人會問:那想執行同步任務怎麼辦?其實很簡單——把同步任務改造異步化有很多種方法,反過來卻很難。

任務隊列接口定義如下:

public interface TaskQueue {
    void addTask(Task task);
    void setListener(TaskQueueListener listener);
    /** 隊列最後不用時應主動銷毀 */
    void destroy();

    interface TaskQueueListener {
        void taskComplete(Task task);
        void taskFailed(Task task, Throwable cause);
    }
}

任務隊列本身的操作也是異步的:addTask 只是把任務放入隊列,至於何時完成或失敗,需監聽 TaskQueueListener。要特別注意,TaskQueueListener 的 taskFailed 與 TaskListener 的 taskFailed 不同——前者表示任務經過若干次重試後最終放棄、徹底失敗,後者只表示某次執行失敗。

我們重點看 TaskQueue 的實現(Task 只關心接口):

public class CallbackBasedTaskQueue implements TaskQueue, Task.TaskListener {
    private static final String TAG = "TaskQueue";
    /** 不需要 thread-safe */
    private Queue taskQueue = new LinkedList();
    private TaskQueueListener listener;
    private boolean stopped;
    /** 一個任務最多重試次數,超過則最終失敗 */
    private static final int MAX_RETRIES = 3;
    /** 當前任務的累計執行次數 */
    private int runCount;

    @Override
    public void addTask(Task task) {
        taskQueue.offer(task);
        task.setListener(this);
        if (taskQueue.size() == 1 && !stopped) {
            launchNextTask(); // 第一個排隊任務,立即執行
        }
    }

    @Override
    public void setListener(TaskQueueListener listener) {
        this.listener = listener;
    }

    @Override
    public void destroy() {
        stopped = true;
    }

    private void launchNextTask() {
        Task task = taskQueue.peek(); // 取隊頭但不移除
        if (task == null) {
            Log.e(TAG, "impossible: NO task in queue, unexpected!");
            return;
        }
        Log.d(TAG, "start task (" + task.getTaskId() + ")");
        task.start();
        runCount = 1;
    }

    @Override
    public void taskComplete(Task task) {
        Log.d(TAG, "task (" + task.getTaskId() + ") complete");
        finishTask(task, null);
    }

    @Override
    public void taskFailed(Task task, Throwable error) {
        if (runCount < MAX_RETRIES && !stopped) {
            Log.d(TAG, "task (" + task.getTaskId() + ") failed, try again. runCount: " + runCount);
            task.start();
            runCount++;
        } else {
            Log.d(TAG, "task (" + task.getTaskId() + ") failed, final failed! runCount: " + runCount);
            finishTask(task, error);
        }
    }

    /** 任務最終結束(成功或徹底失敗)後的處理 */
    private void finishTask(Task task, Throwable error) {
        if (listener != null && !stopped) {
            try {
                if (error == null) {
                    listener.taskComplete(task);
                } else {
                    listener.taskFailed(task, error);
                }
            } catch (Throwable e) {
                Log.e(TAG, "", e);
            }
        }
        task.setListener(null);
        taskQueue.poll(); // 出隊列
        if (taskQueue.size() > 0 && !stopped) {
            launchNextTask(); // 啟動下一個
        }
    }
}

這個實現中有幾點值得留意:

  • 所有進出隊列操作(offer、peek、poll)都在主線程執行,所以隊列結構不必線程安全,我們選用了 LinkedList。
  • 任務的啟動依賴兩個時機:一是 addTask 時若隊列原為空,立即啟動;二是某任務結束後若還有排隊任務,取下一個啟動。
  • 一次執行失敗不算失敗,還要重試若干次;超過 MAX_RETRIES 才算徹底失敗,runCount 記錄累計執行次數。

CallbackBasedTaskQueue 揭示了任務隊列的基本實現模式。失敗重試策略大大提升了最終成功率——演示程序裡我把 Task 失敗概率設得很高(高達 80%),在重試 3 次的配置下,仍有較大概率最終執行成功。

基於 RxJava 的任務隊列

RxJava 到底有什麼用?有人說是為了異步,有人說好在各種 lift 變換,也有人說最大價值是 Schedulers 能方便切換線程。這些都不是革命性的關鍵。我認為,關鍵在於它對回調接口設計的根本性影響:它消除了「為每個異步接口單獨定義回調接口」的必要。

我們用 RxJava 重寫 TaskQueue 接口:

public interface TaskQueue {
    /** 添加任務,返回一個 Observable 供調用者獲取執行結果 */
    (R) Observable(R) addTask(Task(R) task); (此處圓括號代替尖括號)

    /** 隊列最後不用時應主動銷毀 */
    void destroy();
}

仔細看這個改動:

  • 原來的回調接口 TaskQueueListener 消失了。
  • addTask 從無返回值變為返回一個 Observable。調用者拿到它並 subscribe,就能獲得任務結果(成功或失敗)。這一改動很關鍵:原本 addTask 什麼都不返回,要拿結果必須監聽回調,這是典型的異步運作方式;而返回 Observable 後,它感覺上就非常像一個同步接口了。說得抽象點,這個 Observable 是我們站在當下對未來的一個指代——本來尚未運行、發生在未來、虛無縹緲的任務,此刻有了一個實實在在的東西握在手裡,我們還能當下就對它做很多操作,並與其他 Observable 結合。這才是它真正強大之處。

相應地,Task 接口也能這樣改:

/** 異步任務接口定義,不再用 TaskListener,改用 Observable */
public interface Task (R) { (此處圓括號代替尖括號)
    String getTaskId();
    /** 啟動任務,需在主線程執行;返回 Observable 供獲取結果 */
    Observable(R) start(); (此處圓括號代替尖括號)
}

接口討論清楚了,具體的隊列實現反而不那麼重要,詳情可參見 GitHub。要注意,GitHub 實現裡有個小技巧:把異步任務封裝成 Observable,可以使用 AsyncOnSubscribe。

總結

再說 TSQ:它在客戶端雖少用,卻非沒有意義。實際上,客戶端的 Run Loop(即 Android 的 Looper)本身就是一個 TSQ,否則無法在不同線程間安全傳遞消息、調度任務。正因為有了 Run Loop,我們才可能用無鎖方式實現任務隊列。順帶一提,Android 的 android.os.Looper 最終依賴 Linux 內核大名鼎鼎的 epoll 事件機制。

本文忽略的細節:要打造生產可用的任務隊列,還需考慮:執行進度回調、任務取消與暫停、可配置的細節參數(如最大重試次數)、長生命週期隊列與短生命週期頁面的交互、Android 中通常用 Service 封裝這類後台組件、服務端需慎重去重,以及失敗後錯誤處理的複雜化等。

RxJava 的優缺點:它確實簡化了接口、省去了回調設計,讓調用者能用統一方式處理異步任務。但也帶來問題:它比較重、非常抽象、難以理解,對實現者尤其吃力;Observable 依賴 subscribe 才能驅動上游運行,只 addTask 卻不訂閱,任務根本不會執行(有點像「觀察影響結果」的量子力學);受此影響,第一個任務的真正啟動會延遲到 subscribe 之後,且執行線程可能受 Schedulers 設置影響而不在主線程;此外調試時會出現古怪難懂的調用棧。

綜合來看,若要實現完整功能或開源,我可能不會讓它絕對依賴 RxJava,而會像 Retrofit 那樣同時支持自家輕量異步機制與 RxJava。

最後拋一個開放性問題:文中代碼大量使用匿名類(近似 Java 8 的 lambda),使對象間引用關係變得複雜。那麼這些引用關係如何隨程序執行建立、最終銷毀時又如何解除?是否存在內存洩露?歡迎留言討論。下一篇我們將探討更複雜的話題:異步任務的取消。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved