一级毛片免费不卡在线视频,亚洲日本一区二区三区在线不卡 ,视频免费1区二区三区

場景介紹

如果應用的業務邏輯比較復雜，可能需要創建多個線程來執行多個任務。這種情況下，代碼復雜難以維護，任務與線程的交互也會更加繁雜。要解決此問題，開發者可以使用“TaskDispatcher”來分發不同的任務。

接口說明

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

為保證應用有更好的響應性，我們需要設計任務的優先級。在 UI 線程上運行的任務默認以高優先級運行，如果某個任務無需等待結果，則可以用低優先級。

優先級	詳細描述
HIGH	最高任務優先級，比默認優先級、低優先級的任務有更高的幾率得到執行。
DEFAULT	默認任務優先級，比低優先級的任務有更高的幾率得到執行。
LOW	低任務優先級，比高優先級、默認優先級的任務有更低的幾率得到執行。

TaskDispatcher 具有多種實現，每種實現對應不同的任務分發器。在分發任務時可以指定任務的優先級，由同一個任務分發器分發出的任務具有相同的優先級。系統提供的任務分發器有 GlobalTaskDispatcher、ParallelTaskDispatcher、SerialTaskDispatcher 、SpecTaskDispatcher。

GlobalTaskDispatcher
全局并發任務分發器，由 Ability 執行 getGlobalTaskDispatcher()獲取。適用于任務之間沒有聯系的情況。一個應用只有一個 GlobalTaskDispatcher，它在程序結束時才被銷毀。

 TaskDispatcher globalTaskDispatcher = getGlobalTaskDispatcher(TaskPriority.DEFAULT);

ParallelTaskDispatcher
并發任務分發器，由 Ability 執行 createParallelTaskDispatcher() 創建并返回。與 GlobalTaskDispatcher 不同的是，ParallelTaskDispatcher 不具有全局唯一性，可以創建多個。開發者在創建或銷毀 dispatcher 時，需要持有對應的對象引用。

String dispatcherName = "parallelTaskDispatcher";
TaskDispatcher parallelTaskDispatcher = createParallelTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);

SerialTaskDispatcher
串行任務分發器，由 Ability 執行 createSerialTaskDispatcher()創建并返回。由該分發器分發的所有的任務都是按順序執行，但是執行這些任務的線程并不是固定的。如果要執行并行任務，應使用 ParallelTaskDispatcher 或者 GlobalTaskDispatcher，而不是創建多個 SerialTaskDispatcher。如果任務之間沒有依賴，應使用GlobalTaskDispatcher 來實現。它的創建和銷毀由開發者自己管理，開發者在使用期間需要持有該對象引用。

 String dispatcherName = "serialTaskDispatcher";
TaskDispatcher serialTaskDispatcher = createSerialTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);

SpecTaskDispatcher

專有任務分發器，綁定到專有線程上的任務分發器。目前已有的專有線程是主線程。 UITaskDispatcher 和 MainTaskDispatcher 都屬于 SpecTaskDispatcher。建議使用 UITaskDispatcher。

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

TaskDispatcher uiTaskDispatcher = getUITaskDispatcher();

MainTaskDispatcher：由 Ability 執行 getMainTaskDispatcher() 創建并返回。

  TaskDispatcher mainTaskDispatcher= getMainTaskDispatcher()

開發步驟

syncDispatch

同步派發任務：派發任務并在當前線程等待任務執行完成。在返回前，當前線程會被阻塞。

如下代碼示例展示了如何使用 GlobalTaskDispatcher 派發同步任務：

globalTaskDispatcher.syncDispatch(new Runnable() {
              @Override
              public void run() {
                  HiLog.info(label, "sync task1 run");
              }
          });
  HiLog.info(label, "after sync task1");
   
  globalTaskDispatcher.syncDispatch(new Runnable() {
              @Override
              public void run() {
                  HiLog.info(label, "sync task2 run");
              }
          });
  HiLog.info(label, "after sync task2");
   
  globalTaskDispatcher.syncDispatch(new Runnable() {
              @Override
              public void run() {
                  HiLog.info(label, "sync task3 run");
              }
          });
  HiLog.info(label, "after sync task3");
   
  // 執行結果如下：
  // sync task1 run
  // after sync task1
  // sync task2 run
  // after sync task2
  // sync task3 run
  // after sync task3

說明

如果對 syncDispatch 使用不當, 將會導致死鎖。如下情形可能導致死鎖發生：

在專有線程上，利用該專有任務分發器進行 syncDispatch。
在被某個串行任務分發器（dispatcher_a）派發的任務中，再次利用同一個串行任務分發器（dispatcher_a）對象派發任務。
在被某個串行任務分發器（dispatcher_a）派發的任務中，經過數次派發任務，最終又利用該（dispatcher_a）串行任務分發器派發任務。例如：dispatcher_a 派發的任務使用 dispatcher_b 進行任務的派發，在 dispatcher_b 派發的任務中又利用 dispatcher_a 進行派發任務。
串行任務分發器（dispatcher_a）派發的任務中利用串行任務分發器（dispatcher_b）進行同步派發任務，同時 dispatcher_b 派發的任務中利用串行任務分發器（dispatcher_a）進行同步派發任務。在特定的線程執行順序下將導致死鎖。
asyncDispatch

異步派發任務：派發任務，并立即返回，返回值是一個可用于取消任務的接口。

如下代碼示例展示了如何使用 GlobalTaskDispatcher 派發異步任務：

  Revocable revocable =  globalTaskDispatcher.asyncDispatch(new Runnable() {
          @Override
              public void run() {
                  HiLog.info(label, "async task1 run");
              }
          });
  HiLog.info(label, "after async task1");
   
  // 執行結果可能如下：
  // after async task1
  // async task1 run

delayDispatch

異步延遲派發任務：異步執行，函數立即返回，內部會在延時指定時間后將任務派發到相應隊列中。延時時間參數僅代表在這段時間以后任務分發器會將任務加入到隊列中，任務的實際執行時間可能晚于這個時間。具體比這個數值晚多久，取決于隊列及內部線程池的繁忙情況。

如下代碼示例展示了如何使用 GlobalTaskDispatcher 延遲派發任務：

 final long callTime = System.currentTimeMillis();
   final long delayTime = 50;
   Revocable revocable =  globalTaskDispatcher.delayDispatch(new Runnable() {
              @Override
              public void run() {
                  HiLog.info(label, "delayDispatch task1 run");
                  final long actualDelayMs = System.currentTimeMillis() - callTime;
                  HiLog.info(label, "actualDelayTime >= delayTime : %{public}b" + (actualDelayMs >= delayTime));
              }
          }, delayTime );
   HiLog.info(label, "after delayDispatch task1");
   
  // 執行結果可能如下：
  // after delayDispatch task1
  // delayDispatch task1 run
  // actualDelayTime >= delayTime : true

Group

任務組：表示一組任務，且該組任務之間有一定的聯系，由 TaskDispatcher 執行 createDispatchGroup 創建并返回。將任務加入任務組，返回一個用于取消任務的接口。

如下代碼示例展示了任務組的使用方式：將一系列相關聯的下載任務放入一個任務組，執行完下載任務后關閉應用。

  void groupTest(Context context) {
      TaskDispatcher dispatcher = context.createParallelTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);
      // 創建任務組。
      Group group = dispatcher.createDispatchGroup();
      // 將任務1加入任務組，返回一個用于取消任務的接口。
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "download task1 is running");
              downLoadRes(url1);
          }
      });
     // 將與任務1相關聯的任務2加入任務組。
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "download task2 is running");
              downLoadRes(url2);
          }
      });
      // 在任務組中的所有任務執行完成后執行指定任務。
      dispatcher.groupDispatchNotify(group, new Runnable(){
          public void run() {
              HiLog.info(label, "the close task is running after all tasks in the group are completed");
              closeApp();
          }
      });
  }
  ?
  // 可能的執行結果:
  // download task1 is running
  // download task2 is running
  // the close task is running after all tasks in the group are completed
   
  // 另外一種可能的執行結果：
  // download task2 is running
  // download task1 is running
  // the close task is running after all tasks in the group are completed

Revocable

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

如下代碼示例展示了如何取消一個異步延時任務：


  void postTaskAndRevoke(Context context) {
      TaskDispatcher dispatcher = context.getUITaskDispatcher();
      Revocable revocable = dispatcher.delayDispatch(new Runnable(){
           HiLog.info(label, "delay dispatch");
      }, 10);
      boolean revoked = revocable.revoke();
      HiLog.info(label, "%{public}b", revoked);
  }
  ?
  // 一種可能的結果如下 :
  // true

syncDispatchBarrier

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

說明

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

如下代碼示例展示了如何同步設置屏障：

     TaskDispatcher dispatcher = context.createParallelTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);
      // 創建任務組。
      Group group = dispatcher.createDispatchGroup();
      // 將任務加入任務組，返回一個用于取消任務的接口。
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "task1 is running");  // 1
          }
      });
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "task2 is running");  // 2
          }
      });
      
      dispatcher.syncDispatchBarrier(new Runnable() {  
      public void run() {  
          HiLog.info(label, "barrier");  // 3
      }});  
      HiLog.info(label, "after syncDispatchBarrier");  // 4
  }
  ?
  // 1和2的執行順序不定；3和4總是在1和2之后按順序執行。
   
  // 可能的執行結果:
  // task1 is running
  // task2 is running
  // barrier
  // after syncDispatchBarrier
   
  // 另外一種執行結果：
  // task2 is running
  // task1 is running
  // barrier
  // after syncDispatchBarrier

asyncDispatchBarrier

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

說明

在全局并發任務分發器（GlobalTaskDispatcher）上異步設置任務屏障，將不會起到屏障作用。可以使用并發任務分發器（ParallelTaskDispatcher）分離不同的任務組，達到微觀并行、宏觀串行的行為。

如下代碼示例展示了如何異步設置屏障：

 TaskDispatcher dispatcher = context.createParallelTaskDispatcher(dispatcherName, TaskPriority.DEFAULT);
      // 創建任務組。
      Group group = dispatcher.createDispatchGroup();
      // 將任務加入任務組，返回一個用于取消任務的接口。
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "task1 is running");  // 1
          }
      });
      dispatcher.asyncGroupDispatch(group, new Runnable(){
          public void run() {
              HiLog.info(label, "task2 is running");  // 2
          }
      });
      
      dispatcher.asyncDispatchBarrier(new Runnable() {  
          public void run() {  
              HiLog.info(label, "barrier");  // 3
          }
  });  
      HiLog.info(label, "after syncDispatchBarrier");  // 4
  }
  ?
  // 1和2的執行順序不定，但總在3和4之前執行；4可能在3之前執行
   
  // 可能的執行結果:
  // task1 is running
  // task2 is running
  // after syncDispatchBarrier
  // barrier

applyDispatch

執行多次任務：對指定任務執行多次。

如下代碼示例展示了如何執行多次任務：


   final int total = 10;
   final CountDownLatch latch = new CountDownLatch(total);
   final ArrayList indexList = new ArrayList(total);
   
   // 執行任務 total 次
   dispatcher.applyDispatch((index) -> {
       indexList.add(index);
       latch.countDown();
   }, total);
   
   // 設置任務超時
   try {    
       latch.await();
   } catch (InterruptedException exception) {
      HiLog.info(label, "latch exception");
   }
   HiLog.info(label, "list size matches, %{public}b", (total == indexList.size()));
   
  // 執行結果：
  // list size matches, true

聲明：本文內容及配圖由入駐作者撰寫或者入駐合作網站授權轉載。文章觀點僅代表作者本人，不代表電子發燒友網立場。文章及其配圖僅供工程師學習之用，如有內容侵權或者其他違規問題，請聯系本站處理。舉報投訴