搞懂Dart異步并封裝Isolate

Dart 是單線程，那么怎么異步呢？或者耗時為什么不卡線程呢？

Dart 代碼運行在單個執行線程中，Flutter 引擎并不是單線程

Flutter 引擎并不會創建線程，embedder提供給4個 task runner 引用給Flutter 引擎：

  • Platform Task Runner
  • UI Task Runner
  • GPU Task Runner
  • IO Task Runner

所有的 Dart 代碼均運行在一個 isolate 的上下文環境中，該 isolate 中擁有對應 Dart 代碼片段運行所需的所有內存。那么在開發中，我們經常會遇到一些耗時的操作，比如網絡請求、文件讀取等等，那么線程勢必會阻塞，無法響應其他時間，UI 卡死，那么怎么在單線程處理耗時操作呢？

通常我們會使用一個Future 對象用于表示異步操作的結果，這些正在處理的操作或 I/O 將會在稍后完成。那么Future是怎么實現單線程異步呢？

Event loop

1.png

事件觸發，如點擊、重繪，事件循環取到事件，處理，丟棄。就像快遞送到收件人手里，被拆開、拿走快遞、丟掉快遞袋子。而`Future修飾的函數，類似一個冷凍箱，放在快遞人手里，并不拆開，而是別人解凍處理后，然后告訴收件人可以拆了，收件人再拆開。這期間，CPU 則去調度執行其他IO，等異步處理完成，這個結果會被放入事件循環，事件循環處理這個結果。

上面說到異步處理，許多文章都一筆帶過，我們不免頭大，并沒有解惑，為什么單線程可以異步處理？下面從 Future的建立說起:

Future會創建 Timer，并將timer_impl.dart中_Timer對象的靜態方法_handleMessage()放入到isolate_patch.dart中_RawReceivePortImpld對象的靜態成員變量_handlerMap；并創建ReceivePort和SendPort，這里就和Android線程間通信的 Hander一樣，Future會把任務交給操作系統去執行，然后自己繼續執行別的任務。比如說，網絡請求，Socket 本身提供了 select 模型可以異步查詢；而文件 IO，操作系統也提供了基于事件的回調機制。等事件處理完，再把結果發回ReceivePort，事件循環去處理這個結果。

那么別的負載大的耗時操作呢？比如通用的耗時計算任務，例如求解階乘，os 并沒有異步接口給 Dart 調用，所以異步編程幫助不大，這時候就需要多線程去處理了，而 Dart 的多線程就是 isolate，但是isolate并不是內存共享的，它更像是一個進程。

isolate 運用

最簡單的 compute

通常網絡返回 json ，我們需要解析成 實體 bean ，如果 json 十分龐大，耗時較多，就卡頓了。所以需要放在isolate里處理。

import 'dart:convert';

main(List<String> args) {
  String jsonString = '''{ "id":"123", "name":"張三", "score" : 95}''';
  Student student = parseJson(jsonString);
  print(student.name);
}

Student parseJson(String json) {
  Map<String, dynamic> map = jsonDecode(json);
  return Student.fromJson(map);
}

class Student {
  String id;
  String name;
  int score;
  Student({this.id, this.name, this.score});
  factory Student.fromJson(Map parsedJson) {
    return Student(id: parsedJson['id'], name: parsedJson['name'], score: parsedJson['score']);
  }
}

我們把上面代碼放入isolate中執行：

Future<Student> loadStudent(String json) {
  return compute(parseJson, json);
}

Student parseJson(String json) {
  Map<String, dynamic> map = jsonDecode(json);
  return Student.fromJson(map);
}

compute是 Flutter 的 api ，幫我們封裝了 isolate，使用十分簡單，但是也有局限性， 它沒有辦法多次返回結果，也沒有辦法持續性的傳值計算，每次調用，相當于新建一個隔離，如果同時調用過多的話反而會多次開辟內存。在某些業務下，我們可以使用compute，但是在另外一些業務下，我們只能使用dart提供的 isolate了。

單向通信 isolate

我們把上面的代碼利用isolate實現一遍：

import 'dart:convert';
import 'dart:isolate';

main(List<String> args) async {
  await start();
}

Isolate isolate;

start() async {
  //創建接收端口，用來接收子線程消息
  ReceivePort receivePort = ReceivePort();

  //創建并發Isolate，并傳入主線程發送端口
  isolate = await Isolate.spawn(entryPoint, receivePort.sendPort);
  //監聽子線程消息
  receivePort.listen((data) {
    print('Data：$data');
  });
}

//并發Isolate
entryPoint(SendPort sendPort) {
  String jsonString = '''{ "id":"123", "name":"張三", "score" : 95}''';
  Student student = parseJson(jsonString);
  sendPort.send(student);
}

Student parseJson(String json) {
  Map<String, dynamic> map = jsonDecode(json);
  return Student.fromJson(map);
}

class Student {
  String id;
  String name;
  int score;
  Student({this.id, this.name, this.score});
  factory Student.fromJson(Map parsedJson) {
    return Student(id: parsedJson['id'], name: parsedJson['name'], score: parsedJson['score']);
  }
}

有時候，我們需要傳參給子線程，或者像線程池一樣可以管理這個isolate，那么我們就需要實現雙向通信：

import 'dart:isolate';

main(List<String> args) async {
  await start();
  await Future.delayed(Duration(seconds: 1), () {
    threadPort.send('我來自主線程');
    print('1');
  });
  await Future.delayed(Duration(seconds: 1), () {
    threadPort.send('我也來自主線程');
    print('2');
  });
  await Future.delayed(Duration(seconds: 1), () {
    threadPort.send('end');
    print('3');
  });
}

Isolate isolate;
//子線程發送端口
SendPort threadPort;
start() async {
  //創建主線程接收端口，用來接收子線程消息
  ReceivePort receivePort = ReceivePort();

  //創建并發Isolate，并傳入主線程發送端口
  isolate = await Isolate.spawn(entryPoint, receivePort.sendPort);
  //監聽子線程消息
  receivePort.listen((data) {
    print('主線程收到來自子線程的消息$data');
    if (data is SendPort) {
      threadPort = data;
    }
  });
}

//并發Isolate
entryPoint(dynamic message) {
  //創建子線程接收端口，用來接收主線程消息
  ReceivePort receivePort = ReceivePort();

  SendPort sendPort;
  print('==entryPoint==$message');
  if (message is SendPort) {
    sendPort = message;
    print('子線程開啟');
    sendPort.send(receivePort.sendPort);
    //監聽子線程消息
    receivePort.listen((data) {
      print('子線程收到來自主線程的消息$data');
      assert(data is String);
      if (data == 'end') {
        isolate?.kill();
        isolate = null;
        print('子線程結束');
        return;
      }
    });
    return;
  }
}


==entryPoint==SendPort
子線程開啟
主線程收到來自子線程的消息SendPort
1
子線程收到來自主線程的消息我來自主線程
2
子線程收到來自主線程的消息我也來自主線程
3
子線程收到來自主線程的消息end
子線程結束

雙向通信比較復雜，所以我們需要封裝下，通過 api 讓外部調用：

?

import 'dart:async';
import 'dart:isolate';

main(List<String> args) async {
  var worker = Worker();
  worker.reuqest('發送消息1').then((data) {
    print('子線程處理后的消息:$data');
  });

  Future.delayed(Duration(seconds: 2), () {
    worker.reuqest('發送消息2').then((data) {
      print('子線程處理后的消息:$data');
    });
  });
}

class Worker {
  SendPort _sendPort;
  Isolate _isolate;
  final _isolateReady = Completer<void>();
  final Map<Capability, Completer> _completers = {};

  Worker() {
    init();
  }

  void dispose() {
    _isolate.kill();
  }

  Future reuqest(dynamic message) async {
    await _isolateReady.future;
    final completer = new Completer();
    final requestId = new Capability();
    _completers[requestId] = completer;
    _sendPort.send(new _Request(requestId, message));
    return completer.future;
  }

  Future<void> init() async {
    final receivePort = ReceivePort();
    final errorPort = ReceivePort();
    errorPort.listen(print);
    receivePort.listen(_handleMessage);
    _isolate = await Isolate.spawn(
      _isolateEntry,
      receivePort.sendPort,
      onError: errorPort.sendPort,
    );
  }

  void _handleMessage(message) {
    if (message is SendPort) {
      _sendPort = message;
      _isolateReady.complete();
      return;
    }
    if (message is _Response) {
      final completer = _completers[message.requestId];
      if (completer == null) {
        print("Invalid request ID received.");
      } else if (message.success) {
        completer.complete(message.message);
      } else {
        completer.completeError(message.message);
      }
      return;
    }
    throw UnimplementedError("Undefined behavior for message: $message");
  }

  static void _isolateEntry(dynamic message) {
    SendPort sendPort;
    final receivePort = ReceivePort();

    receivePort.listen((dynamic message) async {
      if (message is _Request) {
        print('子線程收到：${message.message}');
        sendPort.send(_Response.ok(message.requestId, '處理后的消息'));
        return;
      }
    });

    if (message is SendPort) {
      sendPort = message;
      sendPort.send(receivePort.sendPort);
      return;
    }
  }
}

class _Request {
  /// The ID of the request so the response may be associated to the request's future completer.
  final Capability requestId;

  /// The actual message of the request.
  final dynamic message;

  const _Request(this.requestId, this.message);
}

class _Response {
  /// The ID of the request this response is meant to.
  final Capability requestId;

  /// Indicates if the request succeeded.
  final bool success;

  /// If [success] is true, holds the response message.
  /// Otherwise, holds the error that occured.
  final dynamic message;

  const _Response.ok(this.requestId, this.message) : success = true;

  const _Response.error(this.requestId, this.message) : success = false;
}
?著作權歸作者所有,轉載或內容合作請聯系作者
平臺聲明：文章內容（如有圖片或視頻亦包括在內）由作者上傳并發布，文章內容僅代表作者本人觀點，簡書系信息發布平臺，僅提供信息存儲服務。