iso机制和异步编程

author:andy

isolate机制

Dart是基于单线程模型的语言。但是在开发当中我们经常会进行耗时操作比如网络请求，这种耗时操作会堵塞我们的代码，所以在Dart也有并发机制，名叫isolate。APP的启动入口main函数就是一个类似Android主线程的一个主isolate。和Java的Thread不同的是，Dart中的isolate无法共享内存。

android--主线程，子线程

dart--主isolate,子isolate

疑问
1.java通过子线程执行耗时操作，那么dart语言没有子线程，如何执行耗时的操作

import 'dart:isolate';

void main() {
  Isolate.spawn(entryPoint, "dahai isolate");
  print(‘主isolate打印的。。。’);
}

void entryPoint(String msg) {
  print(msg);
}

疑问
2.上面打印的k会打印成什么？

import 'dart:isolate';
int k;
void main() {
  k = 10;
  Isolate.spawn(entryPoint, "dahai isolate");
}

void entryPoint(String msg) {
  print(k);
}

疑问
3.主isolate和子isolate如何实现数据交互

void main() {
  //主isolate 接收器
  ReceivePort receivePort = new ReceivePort();

  //把主接收器的发送器，传送给子isolate
  Isolate.spawn(entryPoint, receivePort.sendPort);

  //主isolate接收的信息打印
  receivePort.listen((data) {
    print(data);
  });
}

void entryPoint(SendPort sendPort) {
  sendPort.send('我是来自于子isolate线程');
}

[图片上传失败...(image-b747c2-1600608831069)]

isolate机制跟Android 的handler机制十分相似,都是使用队列循环读取，那么有啥差别呢？

void main() {
  ReceivePort receivePort = ReceivePort();
  receivePort.sendPort.send('任务队列1');
  receivePort.sendPort.send('任务队列2');
  receivePort.sendPort.send('任务队列3');
  Future.microtask(() {
    print('微任务1');
  });
  Future.microtask(() {
    print('微任务1');
  });
  Future.microtask(() {
    print('微任务1');
  });
  receivePort.listen((t) {
    print(t);
  });
}

同Android Handler类似，在Dart运行环境中也是靠事件驱动的，通过event loop不停的从队列中获取消息或者事件来驱动整个应用的运行，isolate发过来的消息就是通过loop处理。但是不同的是在Android中每个线程只有一个Looper所对应的MessageQueue，而Dart中有两个队列，一个叫做event queue(事件队列)，另一个叫做microtask queue(微任务队列)。

isolate数据通讯.png

Dart在执行完main函数后，就会由Loop开始执行两个任务队列中的Event。首先Loop检查微服务队列，依次执行Event，当微服务队列执行完后，就检查Event queue队列依次执行，在执行Event queue的过程中，没执行完一个Event就再检查一次微服务队列。所以微服务队列优先级高，可以利用微服务进行插队。

我们先来看个例子:


import 'dart:io';


void main() {
  new File("abc.txt").readAsString().then((t) {
    print(t);
  });

  while (true) {}
}

疑问：这个方法能够打印出来吗？

异步编程(Future 和 async-await)

Future(flutter中重要的一个异常调用)

在 Dart 库中随处可见 Future 对象，通常异步函数返回的对象就是一个 Future。当一个 future 执行完后，他里面的值就可以使用了，可以使用 then() 来在 future 完成的时候执行其他代码。Future对象其实就代表了在事件队列中的一个事件的结果。

组合

then()的返回值同样是一个future对象，可以利用队列的原理进行组合异步任务

  import 'dart:io';


void main() {
  new File("abc.txt").readAsString().then((t) {
    print(t);
    return 100;
  }).then((t) {
    print(t);
  });
}

上面的方式是等待执行完成读取文件之后，再执行一个新的future。如果我们需要等待一组任务都执行完成再统一处理一些事情，可以通过wait()完成。

 import 'dart:io';

void main() {
  Future future = new File("abc.txt").readAsString();

  Future future2 = Future.delayed(Duration(seconds: 3));

  Future.wait([future, future2]).then((values) {
    print(values[0]);
    print(values[1]);
  });
}

async/await

使用async和await的代码是异步的，但是看起来很像同步代码。当我们需要获得A的结果，再执行B，时，你需要then()->then(),但是利用async与await能够非常好的解决回调地狱的问题：

//async 表示这是一个异步方法,await必须再async方法中使用
//异步方法只能返回 void和Future
import 'dart:io';


void main() {
  readNet().then((t) {
    print(t);
  });
}

Future<String> readNet() async {
  String str1 = await new File("abc.txt").readAsString();
  String str2 = await new File("123.txt").readAsString();
  return "$str1 $str2";
}

isolate机制和异步编程