HarmonyOS Sample 之 TaskDispatcher線程管理

作者：Buty9147 2021-09-15 14:55:49

不同應用在各自獨立的進程中運行。當應用以任何形式啟動時，系統為其創建進程，該進程將持續運行。當進程完成當前任務處于等待狀態，且系統資源不足時，系統自動回收。

https://harmonyos.51cto.com

1.介紹

在啟動應用時，系統會為該應用創建一個稱為“主線程”的執行線程。該線程隨著應用創建或消失，是應用的核心線程。UI界面的顯示和更新等操作，都是在主線程上進行。主線程又稱UI線程，默認情況下，所有的操作都是在主線程上執行。如果需要執行比較耗時的任務(如下載文件、查詢數據庫)，可創建其他線程來處理。

如果應用的業務邏輯比較復雜，可能需要創建多個線程來執行多個任務。這種情況下，代碼復雜難以維護，任務與線程的交互也會更加繁雜。

要解決此問題，開發者可以使用“TaskDispatcher”來分發不同的任務。

比如前段時間 “疫情助手” 的卡片應用，需要獲取位置信息并進行逆地理編碼，安康碼的生成，這些功能就需要單獨創建多個線程來執行任務。

2.搭建環境

安裝DevEco Studio，詳情請參考DevEco Studio下載。

設置DevEco Studio開發環境，DevEco Studio開發環境需要依賴于網絡環境，需要連接上網絡才能確保工具的正常使用，可以根據如下兩種情況來配置開發環境：

如果可以直接訪問Internet，只需進行下載HarmonyOS SDK操作。

如果網絡不能直接訪問Internet，需要通過代理服務器才可以訪問，請參考配置開發環境。

下載源碼后，使用DevEco Studio 打開項目。

3.理論支持

TaskDispatcher是一個任務分發器，它是Ability分發任務的基本接口，隱藏任務所在線程的實現細節。

TaskDispatcher具有多種實現，每種實現對應不同的任務分發器。在分發任務時可以指定任務的優先級，由同一個任務分發器分發出的任務具有相同的優先級。

系統提供的任務分發器有GlobalTaskDispatcher、ParallelTaskDispatcher、SerialTaskDispatcher 、SpecTaskDispatcher。

線程優先級有HIGH、DEFAULT、LOW，執行幾率遞減。

分發器提供了常用的操作，

包括：同步派發任務、異步派發任務、異步延遲派發任務、同步設置屏障任務、異步設置屏障任務、執行多次任務、取消任務、任務組等操作。

后面的實例分析中我們會逐個講解幾種任務分發器的概念和用法。

4.實例講解

4.1.UI界面

UI界面很簡單了，就是為了試驗不同類型的任務分發器而設計的按鈕,如下圖：

HarmonyOS Sample 之 TaskDispatcher線程管理-鴻蒙HarmonyOS技術社區

4.2.后臺代碼

重點在這了，官方代碼結合API提示，增加了注釋說明

4.2.1 GlobalTaskDispatcher 全局并發任務分發器

全局并發任務分發器，由Ability執行getGlobalTaskDispatcher()獲取。

適用于任務之間沒有聯系的情況。一個應用只有一個GlobalTaskDispatcher，它在程序結束時才被銷毀。我們從名字也能看出是get而不是createXXX,具有全局唯一性。

a.同步派發任務

/** 
 * 全局任務分發器 
 * 同步任務,分派一個任務并等待該任務在當前線程中完成。 
 * 
 * @param component 
 */ 
private void syncTask(Component component) { 
    // 
    StringBuffer stringBuffer = new StringBuffer(); 
    //全局并發任務分發器 
    TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "task run..."); 
    try { 
        //同步任務1，分派一個任務并等待該任務在當前線程中完成。 
        globalTaskDispatcher.syncDispatch( 
                () -> { 
                    for (int i = 0; i < 2; i++) { 
                        stringBuffer.append("Sync task1 run").append(System.lineSeparator()); 
                        try { 
                            Thread.sleep(1000); 
                        } catch (InterruptedException e) { 
                            e.printStackTrace(); 
                        } 
                    } 
                    HiLog.debug(LABEL_LOG, "task1 run finished"); 
                }); 
 
        stringBuffer.append("After sync task1").append(System.lineSeparator()); 
 
        //同步任務2，分派一個任務并等待該任務在當前線程中完成。 
        globalTaskDispatcher.syncDispatch(() -> 
        { 
            for (int i = 0; i < 2; i++) { 
                stringBuffer.append("Sync task2 run").append(System.lineSeparator()); 
                try { 
                    Thread.sleep(1000); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
            } 
            HiLog.debug(LABEL_LOG, "task2 run finished"); 
        }); 
 
    } catch (Exception e) { 
        e.printStackTrace(); 
    } 
    stringBuffer.append("After sync task2").append(System.lineSeparator()); 
    HiLog.debug(LABEL_LOG, "task run finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:13:04.204 5526-5526/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:13:06.206 5526-10427/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync task1 run finished 
09-08 00:13:08.208 5526-10610/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync task2 run finished 
09-08 00:13:08.209 5526-5526/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished

b.異步派發任務

/** 
 * 全局任務分發器 
 * 異步任務,分派任務并立即返回值，無需等待任務執行 
 * 
 * @param component 
 */ 
private void asyncTask(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
 
    //全局并發任務分發器 
    TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 
 
    //異步任務，分派任務并立即返回值，無需等待任務執行 
    globalTaskDispatcher.asyncDispatch(() -> { 
        try { 
            Thread.sleep(200); 
        } catch (InterruptedException e) { 
            HiLog.error(LABEL_LOG, "%{public}s", "AsyncDispatch InterruptedException"); 
        } 
        stringBuffer.append("Async task1 run").append(System.lineSeparator()); 
 
        //將同步 Runnable 任務發送到事件隊列。 該線程被阻塞，直到任務被執行。 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async task1 run finished"); 
    }); 
 
 
    stringBuffer.append("After async task1").append(System.lineSeparator()); 
    HiLog.debug(LABEL_LOG, "Main task run continue"); 
    //異步任務2，分派任務并立即返回值，無需等待任務執行 
    globalTaskDispatcher.asyncDispatch(() -> { 
        try { 
            Thread.sleep(200); 
        } catch (InterruptedException e) { 
            HiLog.error(LABEL_LOG, "%{public}s", "AsyncDispatch InterruptedException"); 
        } 
        stringBuffer.append("Async task2 run").append(System.lineSeparator()); 
 
        //將同步 Runnable 任務發送到事件隊列。 該線程被阻塞，直到任務被執行。 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async task2 run finished"); 
    }); 
 
    stringBuffer.append("After async task2").append(System.lineSeparator()); 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:18:27.779 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:18:27.780 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run continue 
09-08 00:18:27.781 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 00:18:28.115 9609-613/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished 
09-08 00:18:28.115 9609-614/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
或 
09-08 00:18:58.635 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:18:58.635 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run continue 
09-08 00:18:58.636 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 00:18:58.840 9609-3584/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
09-08 00:18:58.840 9609-3583/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished

c.異步延遲派發任務

/** 
 * 延遲任務 
 * 在給定的延遲后分派任務。 
 * 這是一個異步執行并立即返回一個值而無需等待。 
 * 
 * @param component 
 */ 
private void delayTask(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
 
    //全局并發任務分發器 
    TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 
    //調用時間 
    final long callTime = System.currentTimeMillis(); 
    HiLog.debug(LABEL_LOG, "Main task run... current1 time:" + callTime); 
    //延遲任務1,在給定的延遲后分派任務,這是一個異步執行并立即返回一個值而無需等待 
    globalTaskDispatcher.delayDispatch(() -> { 
        stringBuffer.append("DelayDispatch task1 run").append(System.lineSeparator()); 
 
        final long actualDelayMs = System.currentTimeMillis() - callTime; 
 
        stringBuffer.append("ActualDelayTime >= delayTime : ").append((actualDelayMs >= DELAY_TIME)); 
 
        //將同步 Runnable 任務發送到事件隊列。 該線程被阻塞，直到任務被執行。 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async task1 run finished duration:" + actualDelayMs); 
    }, DELAY_TIME); 
 
 
    stringBuffer.append("After delayDispatch task1").append(System.lineSeparator()); 
    final long callTime2 = System.currentTimeMillis(); 
    HiLog.debug(LABEL_LOG, "Main task run finished current2 time:" + callTime2); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:20:50.912 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... current1 time:1631031650912 
09-08 00:20:50.913 9609-9609/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished current2 time:1631031650913 
09-08 00:20:51.916 9609-11689/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished duration:1002

d.執行多次任務

執行多次任務：對指定任務執行多次。多次執行的順序也不是固定的。

/** 
 * 執行多次任務 
 * 對指定任務執行多次 
 * 
 * @param component 
 */ 
private void applyDispatchTask(Component component) { 
    StringBuilder stringBuilder = new StringBuilder(); 
 
    //倒計時鎖存器 
    final CountDownLatch latch = new CountDownLatch(TASK_TOTAL); 
    final ArrayList<Long> indexList = new ArrayList<>(TASK_TOTAL); 
 
    TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
    //執行任務 TASK_TOTAL 次 
    globalTaskDispatcher.applyDispatch(index -> { 
        // 
        indexList.add(index); 
        HiLog.debug(LABEL_LOG, "Async task" + index+" run finished"); 
        //遞減鎖存器的計數，如果計數達到零，則釋放所有等待的線程。 
        latch.countDown(); 
    }, TASK_TOTAL); 
 
    try { 
        // 設置任務超時。 
        latch.await(); 
    } catch (InterruptedException exception) { 
        HiLog.error(LABEL_LOG, "%{public}s", "applyDispatchTask InterruptedException"); 
    } 
    stringBuilder.append("List size matches :").append((indexList.size() == TASK_TOTAL)); 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
    resultText.setText(stringBuilder.toString()); 
}

輸出結果

09-08 00:45:23.796 7836-7836/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:45:23.797 7836-18216/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task0 run finished 
09-08 00:45:23.799 7836-18219/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task3 run finished 
09-08 00:45:23.800 7836-18220/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task4 run finished 
09-08 00:45:23.800 7836-18217/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished 
09-08 00:45:23.801 7836-18218/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
09-08 00:45:23.801 7836-18221/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task5 run finished 
09-08 00:45:23.801 7836-18222/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task6 run finished 
09-08 00:45:23.802 7836-18223/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task7 run finished 
09-08 00:45:23.802 7836-18224/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task8 run finished 
09-08 00:45:23.802 7836-18225/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task9 run finished 
09-08 00:45:23.803 7836-7836/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished

4.2.2 ParallelTaskDispatcher 并發任務分發器

并發任務分發器，由Ability執行createParallelTaskDispatcher()創建并返回。

與GlobalTaskDispatcher不同的是，ParallelTaskDispatcher不具有全局唯一性，可以創建多個。開發者在創建或銷毀dispatcher時，需要持有對應的對象引用。

a.同步設置屏障任務

同步設置屏障任務：在任務組上設立任務執行屏障，同步等待任務組中的所有任務執行完成，再執行指定任務。

在全局并發任務分發器(GlobalTaskDispatcher)上同步設置任務屏障，將不會起到屏障作用。

/** 
 * 同步設置屏障任務 
 * 在任務組上設立任務執行屏障，同步等待任務組中的所有任務執行完成，再執行指定任務 
 * 在全局并發任務分發器（GlobalTaskDispatcher）上同步設置任務屏障，將不會起到屏障作用。 
 * 
 * @param component 
 */ 
private void syncBarrier(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
    //并發任務分發器，不具有全局唯一性，可以創建多個 
    TaskDispatcher dispatcher = createParallelTaskDispatcher("SyncBarrierDispatcher", TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
    //創建任務組 
    Group group = dispatcher.createDispatchGroup(); 
 
    //添加異步任務到組中 
    dispatcher.asyncGroupDispatch(group, () -> 
            { 
                stringBuffer.append("Task1 is running").append(System.lineSeparator()); 
                HiLog.debug(LABEL_LOG, "Async task1 run finished"); 
            }); 
    dispatcher.asyncGroupDispatch(group, () -> 
    { 
        stringBuffer.append("Task2 is running").append(System.lineSeparator()); 
        HiLog.debug(LABEL_LOG, "Async task2 run finished"); 
    }); 
 
    //同步設置屏障任務，所有任務執行完成，再執行指定任務 
    dispatcher.syncDispatchBarrier(() -> 
    { 
        stringBuffer.append("Barrier").append(System.lineSeparator()); 
        HiLog.debug(LABEL_LOG, "Sync barrier task run finished"); 
    }); 
 
    stringBuffer.append("After syncDispatchBarrier").append(System.lineSeparator()); 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:28:49.975 31645-31645/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:28:49.980 31645-13304/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished 
09-08 00:28:49.981 31645-13305/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
09-08 00:28:49.982 31645-13306/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync barrier task run finished 
09-08 00:28:49.983 31645-31645/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
或 
09-08 00:32:24.630 31645-31645/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:32:24.633 31645-27346/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
09-08 00:32:24.634 31645-27345/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished 
09-08 00:32:24.636 31645-27347/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync barrier task run finished 
09-08 00:32:24.636 31645-31645/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished

b.異步設置屏障任務

異步設置屏障任務：在任務組上設立任務執行屏障后直接返回，指定任務將在任務組中的所有任務執行完成后再執行。

在全局并發任務分發器(GlobalTaskDispatcher)上異步設置任務屏障，將不會起到屏障作用。

可以使用并發任務分發器(ParallelTaskDispatcher)分離不同的任務組，達到微觀并行、宏觀串行的行為。

/** 
 * 異步設置屏障任務 
 * 在任務組上設立任務執行屏障后直接返回，指定任務將在任務組中的所有任務執行完成后再執行。 
 * 
 * @param component 
 */ 
private void asyncBarrier(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
    //異步任務分發器，不具有全局唯一性，可以創建多個 
    TaskDispatcher dispatcher = createParallelTaskDispatcher("AsyncBarrierDispatcher", TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
    //創建任務組 
    Group group = dispatcher.createDispatchGroup(); 
    //添加異步任務到組中 
    dispatcher.asyncGroupDispatch(group, () -> { 
        stringBuffer.append("Task1 is running").append(System.lineSeparator()); 
 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async Task1 is run finished"); 
    }); 
    //添加異步任務到組中 
    dispatcher.asyncGroupDispatch(group, () -> { 
        stringBuffer.append("Task2 is running").append(System.lineSeparator()); 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async Task2 is run finished"); 
    }); 
    //異步設置屏障任務 
    dispatcher.asyncDispatchBarrier(() -> { 
        stringBuffer.append("Barrier").append(System.lineSeparator()); 
        // 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async barrier task run finished"); 
 
    }); 
    stringBuffer.append("After asyncDispatchBarrier").append(System.lineSeparator()); 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:35:16.089 11855-11855/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:35:16.092 11855-11855/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 00:35:16.094 11855-8290/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async Task1 is run finished 
09-08 00:35:16.094 11855-8291/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async Task2 is run finished 
09-08 00:35:16.103 11855-8292/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async barrier task run finished 
或 
09-08 00:36:02.736 11855-11855/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:36:02.739 11855-11855/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 00:36:02.742 11855-11611/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async Task2 is run finished 
09-08 00:36:02.743 11855-11610/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async Task1 is run finished 
09-08 00:36:02.744 11855-11613/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async barrier task run finished

c.任務組

任務組：表示一組任務，且該組任務之間有一定的聯系，由TaskDispatcher執行createDispatchGroup創建并返回。

將任務加入任務組，返回一個用于取消任務的接口。

/** 
 * 任務組 
 * 將一系列相關聯的任務放入一個任務組，執行完組內全部任務后執行指定任務 
 * 
 * @param component 
 */ 
private void groupTask(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
 
    //并發任務分發器，不具有全局唯一性，可以創建多個 
    TaskDispatcher dispatcher = createParallelTaskDispatcher("MyParallelTaskDispatcher", TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
    //創建一個分發組 
    Group group = dispatcher.createDispatchGroup(); 
 
    //異步，將任務1加入任務組，返回一個用于取消任務的接口 
    dispatcher.asyncGroupDispatch(group, () -> { 
        stringBuffer.append("GroupTask1 is running").append(System.lineSeparator()); 
        // 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
 
        HiLog.debug(LABEL_LOG, "Group async task1 finished"); 
    }); 
 
    //異步，將與任務1相關聯的任務2加入任務組。 GroupTask1并不一定比GroupTask2先執行完 
    dispatcher.asyncGroupDispatch(group, () -> { 
        stringBuffer.append("GroupTask2 is running").append(System.lineSeparator()); 
        // 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Group async task2 run finished"); 
    }); 
 
    //在任務組中的所有任務執行完成后執行指定任務 
    dispatcher.groupDispatchNotify(group, () -> { 
        stringBuffer.append("This task running after all tasks in the group are completed") 
                .append(System.lineSeparator()); 
        HiLog.debug(LABEL_LOG, "This task running after all tasks in the group are completed"); 
    }); 
 
    //最先執行 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 00:56:43.891 15624-15624/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 00:56:43.893 15624-15624/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 00:56:43.895 15624-32143/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Group async task1 finished 
09-08 00:56:43.895 15624-32144/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Group async task2 run finished 
09-08 00:56:43.896 15624-32147/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  This task running after all tasks in the group are completed

從日志輸出看，說明groupDispatchNotify也是一個異步任務。

4.2.3 SerialTaskDispatcher 串行任務分發器

串行任務分發器，由Ability執行createSerialTaskDispatcher()創建并返回。由該分發器分發的所有的任務都是按順序執行，但是執行這些任務的線程并不是固定的。

如果要執行并行任務，應使用ParallelTaskDispatcher或者GlobalTaskDispatcher，而不是創建多個SerialTaskDispatcher。

如果任務之間沒有依賴，應使用GlobalTaskDispatcher來實現。它的創建和銷毀由開發者自己管理，開發者在使用期間需要持有該對象引用。

/** 
 * 串行任務分發器 
 * 由該分發器分發的所有的任務都是按順序執行，但是執行這些任務的線程并不是固定的。 
 * 如果要執行并行任務，應使用ParallelTaskDispatcher或者GlobalTaskDispatcher，而不是創建多個SerialTaskDispatcher。 
 * 如果任務之間沒有依賴，應使用GlobalTaskDispatcher來實現。它的創建和銷毀由開發者自己管理，開發者在使用期間需要持有該對象引用。 
 * @param component 
 */ 
private void serialTaskDispatcherTask(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
    TaskDispatcher serialTaskDispatcher =createSerialTaskDispatcher("MySerialTaskDispatcher",TaskPriority.DEFAULT); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
 
   /* //同步任務1，分派一個任務并等待該任務在當前線程中完成。 
    serialTaskDispatcher.asyncDispatch( 
            () -> { 
                try { 
                    Thread.sleep(3); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                stringBuffer.append("Async task1 run").append(System.lineSeparator()); 
                HiLog.debug(LABEL_LOG, "Async task1 run finished"); 
            }); 
 
    stringBuffer.append("After sync task1").append(System.lineSeparator()); 
 
    //同步任務2，分派一個任務并等待該任務在當前線程中完成。 
    serialTaskDispatcher.asyncDispatch(() -> 
    { 
        try { 
            Thread.sleep(3); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        stringBuffer.append("Async task2 run").append(System.lineSeparator()); 
        HiLog.debug(LABEL_LOG, "Async task2 run finished"); 
    });*/ 
 
 
    //異步任務1，分派一個任務并等待該任務在當前線程中完成。 
    serialTaskDispatcher.asyncDispatch( 
            () -> { 
                try { 
                    Thread.sleep(3); 
                } catch (InterruptedException e) { 
                    e.printStackTrace(); 
                } 
                stringBuffer.append("Async task1 run").append(System.lineSeparator()); 
                handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
                HiLog.debug(LABEL_LOG, "Async task1 run finished"); 
            }); 
 
    stringBuffer.append("After sync task1").append(System.lineSeparator()); 
 
    //異步任務2，分派一個任務并等待該任務在當前線程中完成。 
    serialTaskDispatcher.asyncDispatch(() -> 
    { 
        try { 
            Thread.sleep(3); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        stringBuffer.append("Async task2 run").append(System.lineSeparator()); 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async task2 run finished"); 
    }); 
    //異步任務3，分派一個任務并等待該任務在當前線程中完成。 
    serialTaskDispatcher.asyncDispatch(() -> 
    { 
        try { 
            Thread.sleep(3); 
        } catch (InterruptedException e) { 
            e.printStackTrace(); 
        } 
        stringBuffer.append("Async task3 run").append(System.lineSeparator()); 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Async task3 run finished"); 
    }); 
 
    HiLog.debug(LABEL_LOG, "Main task run finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

同步派發任務

09-08 01:32:17.493 7945-7945/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 01:32:19.494 7945-2486/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync task1 run finished 
09-08 01:32:21.496 7945-2725/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Sync task2 run finished 
09-08 01:32:21.497 7945-7945/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
 
異步派發任務、 
-08 01:37:07.276 8419-8419/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 01:37:07.277 8419-8419/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run finished 
09-08 01:37:07.277 8419-24172/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task1 run finished 
09-08 01:37:07.288 8419-24173/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task2 run finished 
09-08 01:37:07.290 8419-24178/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Async task3 run finished

從輸出看出所有的任務都是按順序執行的。

4.2.4 SpecTaskDispatcher 專有任務分發器

專有任務分發器，綁定到專有線程上的任務分發器。目前已有的專有線程為UI線程，通過UITaskDispatcher進行任務分發。

UITaskDispatcher：綁定到應用主線程的專有任務分發器，由Ability執行getUITaskDispatcher()創建并返回。由該分發器分發的所有的任務都是在主線程上按順序執行，它在應用程序結束時被銷毀。

a.取消任務

取消任務：Revocable是取消一個異步任務的接口。

異步任務包括通過 asyncDispatch、delayDispatch、asyncGroupDispatch 派發的任務。如果任務已經在執行中或執行完成，則會返回取消失敗。

/** 
 * 提交任務與取消 
 * 取消一個異步任務的接口。 
 * 異步任務包括通過 asyncDispatch、delayDispatch、asyncGroupDispatch 派發的任務。 
 * 如果任務已經在執行中或執行完成，則會返回取消失敗。 
 * 
 * @param component 
 */ 
private void postTaskAndRevoke(Component component) { 
    StringBuffer stringBuffer = new StringBuffer(); 
 
    //專有任務分發器，綁定到應用主線程的專有任務分發器 
    TaskDispatcher dispatcher = getUITaskDispatcher(); 
    HiLog.debug(LABEL_LOG, "Main task run..."); 
    //延遲分發器 
    Revocable revocable = dispatcher.delayDispatch(() -> { 
        stringBuffer.append("Delay dispatch").append(System.lineSeparator()); 
        // 
        handler.postSyncTask(() -> resultText.setText(stringBuffer.toString())); 
        HiLog.debug(LABEL_LOG, "Delay task run finished"); 
    }, 5); 
 
    //取消異步任務 
    boolean revoked = revocable.revoke(); 
    stringBuffer.append("Revoke result :").append(revoked); 
    HiLog.debug(LABEL_LOG, "Main task::delay task revocable finished"); 
    resultText.setText(stringBuffer.toString()); 
}

輸出結果

09-08 01:00:27.184 13669-13669/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task run... 
09-08 01:00:27.184 13669-13669/ohos.samples.taskmanager D 00F00/=>MainAbilitySlice:  Main task::delay task revocable finished

取消成功，所以Delay task run finished 日志并沒有打印。

5.完整代碼

附件直接下載

想了解更多內容，請訪問：

51CTO和華為官方合作共建的鴻蒙技術社區

https://harmonyos.51cto.com