• 1.Dart單線程異步編程模型
  • 1.1 處理耗時操作
  • 1.2 Dart事件循環
• 2. isolate
  • 2.1 為什么需要isolate
  • 2.2 什么是isolate
  • 2.3 isolate并發模型特點
• 3.如何使用isolate
  • 3.1 isolate包介紹
  • 3.2 isolate單向通信
  • 3.3 isolate雙向通信
  • 3.4 isolate的暫停、恢復、結束
  • 3.5 compute函數
  • 3.6 isolate存在的限制
  • 3.7 isolate和普通Thread的區別
  • 3.8 什么場景該使用Future還是isolate

1.Dart單線程異步編程模型

單線程的異步操作？？？

單線程異步操作？？？

在開發中，我們經常會遇到一些耗時的操作需要完成，比如網絡請求，上傳和下載，文件讀取等等；如果在主線程中一直等待這些耗時操作完成，就會發生阻塞，無法響應如用戶點擊等操作。

1.1 處理耗時操作

1. 多線程，比如Java、C++，OC，我們普遍的做法是開啟一個新的線程（Thread），在新的線程中完成這些異步的操作，再通過線程間通信的方式，將拿到的數據傳遞給主線程。
2. 單線程+事件循環，比如JavaScript、Dart都是基于單線程加事件循環來完成耗時操作的處理。

單線程是如何來處理網絡通信、IO操作它們返回的結果呢？答案就是事件循環

1.2 Dart事件循環

單線程模型中主要就是在維護著一個事件循環（Event Loop）。

• 將需要處理的一系列事件（包括點擊事件、IO事件、網絡事件）放在一個事件隊列（Event Queue）中。
• 不斷的從事件隊列（Event Queue）中取出事件，并執行其對應需要執行的代碼塊，直到事件隊列清空位置。

嚴格來劃分的話，在Dart中還存在另一個隊列：微任務隊列（Microtask Queue）。

• 微任務隊列的優先級要高于事件隊列，也就是說事件循環都是優先執行微任務隊列中的任務，再執行 事件隊列 中的任務；
• 所有的外部事件任務都在事件隊列中，如IO、計時器、點擊、以及繪制事件等；
• 而微任務通常來源于Dart內部，并且微任務非常少。這是因為如果微任務非常多，就會造成事件隊列排不上隊，會阻塞任務隊列的執行（比如用戶點擊沒有反應的情況）；

在Dart的單線程中，代碼執行順序：

1. Dart的入口是main函數，所以main函數中的代碼會優先執行；
2. main函數執行完后，會啟動一個事件循環（Event Loop）就會啟動，啟動后開始執行隊列中的任務；
3. 首先，會按照先進先出的順序，執行 微任務隊列（Microtask Queue）中的所有任務；
4. 其次，會按照先進先出的順序，執行 事件隊列（Event Queue）中的所有任務；
   
   image.png

如果在多核CPU中，單線程是不是就沒有充分利用CPU呢？

2. isolate

? 我們知道Dart是單線程模型，也就是實現異步需要借助EventLoop來進行事件驅動。所以Dart只有一個主線程，其實在Dart中并不是叫 Thread ,而是有個專門名詞叫 「isolate(隔離)。其實在Dart也會遇到一些耗時計算的任務，不建議把任務放在主isolate中，否則容易造成UI卡頓，需要開辟一個單獨isolate來獨立執行耗時任務，然后通過消息機制把最終計算結果發送給主isolate實現UI的更新。」 在Dart中異步是并發方案的基礎，Dart支持單個和多個isolate中的異步。
?

2.1 為什么需要isolate

在Dart/Flutter應用程序啟動時，會啟動一個主線程其實也就是Root Isolate, 在Root Isolate內部運行一個EventLoop事件循環。所以所有的Dart代碼都是運行在Isolate之中的，它就像是機器上的一個小空間，具有自己的私有內存塊和一個運行事件循環的單個線程。isolate是提供了Dart/Flutter程序運行環境，包括所需的內存以及事件循環EventLoop對事件隊列和微任務隊列的處理。

2.2 什么是isolate

用官方文檔中定義一句話來概括: An isolated Dart execution context .大概的意思就是 「isolate實際就是一個隔離的Dart執行的上下文環境(或者容器)」。isolate是Dart對 「Actor并發模型」 的實現。運行中的Dart程序由一個或多個「Actor」組成，這些「Actor」其實也就是Dart中的isolate。 「isolate是有自己的內存和單線程控制的事件循環」。是一條獨立的執行線，它們之間只能通過發送消息通信，所以它的資源開銷低于線程。isolate本身的意思是“隔離”，因為 「isolate之間的內存在邏輯上是隔離的，不像Java一樣是共享內存的」。isolate中的代碼是按順序執行的，「任何Dart程序的并發都是運行多個isolate的結果」。因為 「Dart沒有共享內存的并發」，沒有競爭的可能性所以不需要鎖，也就不存在死鎖的問題。

2.3 isolate并發模型特點

isolate可以理解為是概念上Thread線程，但是它和Thread線程唯一不一樣的就是 「多個isolate之間彼此隔離且不共享內存空間，每個isolate都有自己獨立內存空間，從而避免了鎖競爭」。由于每個isolate都是隔離，它們之間的通信就是 「基于Actor并發模型中發送異步消息來實現通信的」，所以更直觀理解把一個isolate當作Actor并發模型中一個Actor即可。在isolate中還有「Port」的概念，分為send port和receive port可以把它理解為Actor模型中每個Actor內部都有對mailbox(信箱)的實現，可以很好地管理Message。

3.如何使用isolate

3.1 isolate包介紹

使用isolate類進行并發操作，需要導入 isolate

import 'dart:isolate';

該Library主要包含下面:

• Isolate 類: Dart代碼執行的隔離的上下文環境
• ReceivePort 類: 它是一個接收消息的 Stream ， ReceivePort 可以生成 SendPort , ReceivePort 接收消息，可以把消息發送給其他的 isolate, 所以要發送消息就需要生成 SendPort , 然后再由 SendPort 發送給對應isolate的 ReceivePort .
• SendPort 類: 將消息發送給isolate, 準確的來說是將消息發送到isolate中的 ReceivePort

此外可以使用 spawn 方法生成一個新的 isolate 對象， spawn 是一個靜態方法返回的是一個 Future<Isolate> , 必傳參數有兩個，函數 entryPoint 和參數 message ,其中 entryPoint函數必須是頂層函數或靜態方法，參數message需要包含SendPort.

external static Future<Isolate> spawn<T>(
      void entryPoint(T message), T message,
      {bool paused = false,
      bool errorsAreFatal = true,
      SendPort? onExit,
      SendPort? onError,
      @Since("2.3") String? debugName});

3.2 isolate單向通信

import "dart:isolate";

void main() async {
  // 1.創建管道
  ReceivePort receivePort= ReceivePort();

  // 2.創建新的Isolate
  Isolate isolate = await Isolate.spawn<SendPort>(foo, receivePort.sendPort);

  // 3.監聽管道消息
  receivePort.listen((data) {
    print('單向通信Data：$data');
    // 不再使用時，我們會關閉管道
    receivePort.close();
    // 需要將isolate殺死
    isolate.kill(priority: Isolate.immediate);
  });
}

void foo(SendPort sendPort) {
  sendPort.send("Hello World");
}

// 打印
// [log] 單向通信data：Hello World

3.3 isolate雙向通信

  /// 雙向通信
  Future<SendPort> initIsolate() async {
    log('initIsolate == ${Isolate.current.debugName}');
    Completer<SendPort> completer = Completer<SendPort>();
    //主isolate中的接收者（接收子isolate中發送的消息）
    ReceivePort mainReceivePort = ReceivePort();
    //接受者的監聽
    mainReceivePort.listen((data) {
      if (data is SendPort) {
        //接收到子isolate中創建的 SendPort，可使用該SendPort向子isolate發送消息
        SendPort newSendPort = data;
        completer.complete(newSendPort);
      } else {
        log('[newIsolateToMainStream] $data');
      }
    });
    //創建子isolate，傳入 入口函數 和 接受者sendPort  ，子isolate可使用該sendPort向主isolate發送消息
    Isolate newIsolateInstance =
        await Isolate.spawn(newIsolate, mainReceivePort.sendPort);
    log('newIsolateInstance == ${newIsolateInstance.debugName}');
    return completer.future;
  }

  /// 子Isolate的入口函數，可以在該函數中做耗時操作
  static void newIsolate(SendPort mainSendPort) {
    log('newIsolate == ${Isolate.current.debugName}');
    ReceivePort newReceivePort = ReceivePort();
    mainSendPort.send(newReceivePort.sendPort);

    newReceivePort.listen((data) {
      log('[mainToNewIsolateStream] $data');
      var sum = 0;
      for (int i = 1; i <= data; i++) {
        sum += I;
      }
      mainSendPort.send('計算結果：$sum');
    });
  }

  void twoWaystart() async {
    SendPort newSendPort = await initIsolate();
    //接收到子ioslate中的 SendPort   可向子isolate中發送消息
    newSendPort.send(1000000000);
  }
  
// 打印
// [log] initIsolate == main
// [log] newIsolate == newIsolate
// [log] newIsolateInstance == newIsolate
// [log] [mainToNewIsolateStream] 1000000000
// [log] [newIsolateToMainStream] 計算結果：500000000500000000

3.4 isolate的暫停、恢復、結束

    //恢復 isolate 的使用
    isolate.resume(isolate.pauseCapability);

    //暫停 isolate 的使用
    isolate.pause(isolate.pauseCapability);

    //結束 isolate 的使用
    isolate.kill(priority: Isolate.immediate);

3.5 compute函數

 // 創建一個新的Isolate，在其中運行任務doWork
  createNewTask() async {
    var str = 'New Task';
    var result = await compute(doWork, str);
    print(result);

    var result2 = await compute(summ, 1000000000);
    print(result2);
  }

  static String doWork(String value) {
    print('new isolate doWork start == ${DateTime.now()}');
    // 模擬耗時5秒
    sleep(const Duration(seconds: 5));

    print('new isolate doWork end == ${DateTime.now()}');
    return "complete:$value";
  }

  //計算0到 num 數值的總和
  static num summ(int num) {
    print('開始計算');
    int count = 0;
    while (num > 0) {
      count = count + num;
      num--;
    }
    print('計算結束');
    return count;
  }
  
// 打印
flutter: new isolate doWork start == 2022-06-21 20:37:43.615597
flutter: new isolate doWork end == 2022-06-21 20:37:48.622028
flutter: complete:New Task
flutter: 開始計算
flutter: 計算結束
flutter: 500000000500000000

3.6 isolate存在的限制

Platform-Channel 通信僅僅由主 isolate 支持。該主 isolate 對應于應用啟動時創建的 isolate。
也就是說，通過編程創建的 isolate 實例，無法實現 Platform-Channel 通信……

3.7 isolate和普通Thread的區別

isolate和普通Thread的區別需要從不同的維度來區分:

1. 從底層操作系統維度
   在isolate和Thread操作系統層面是一樣的，都是會去創建一個OSThread，也就是說最終都是委托創建操作系統層面的線程。

2. 從所起的作用維度
   都是為了應用程序提供一個運行時環境。

3. 從實現機制的維度
   isolate和Thread有著明顯區別就是大部分情況下的Thread都是共享內存的，存在資源競爭等問題，但是isolate彼此之間是不共享內存的。

3.8 什么場景該使用Future還是isolate

用戶將根據不同的因素來評估應用的質量，比如：

• 特性
• 外觀
• 用戶友好性
• ……

你的應用可以滿足以上所有因素，但如果用戶在一些處理過程中遇到了卡頓，這極有可能對你不利。

因此，以下是你在開發過程中應該系統考慮的一些點：

1. 如果代碼片段不能被中斷，使用傳統的同步過程（一個或多個相互調用的方法）；
2. 如果代碼片段可以獨立運行而不影響應用的性能，可以考慮通過 Future 使用 事件循環；
3. 如果繁重的處理可能需要一些時間才能完成，并且可能影響應用的性能，考慮使用 Isolate。

換句話說，建議盡可能地使用 Future（直接或間接地通過 async 方法），因為一旦事件循環擁有空閑時間，這些 Future 的代碼就會被執行。這將使用戶感覺事情正在被并行處理（而我們現在知道事實并非如此）。

另外一個可以幫助你決定使用 Future 或 Isolate 的因素是運行某些代碼所需要的平均時間。

• 如果一個方法需要幾毫秒 => Future
• 如果一個處理流程需要幾百毫秒 => Isolate

以下是一些很好的 Isolate 選項：

• JSON 解碼：解碼 JSON（HttpRequest 的響應）可能需要一些時間 => 使用 compute
• 加密：加密可能非常耗時 => Isolate
• 圖像處理：處理圖像（比如：剪裁）確實需要一些時間來完成 => Isolate
• 從 Web 加載圖像：該場景下，為什么不將它委托給一個完全加載后返回完整圖像的 Isolate？