我们知道Dart是基于单线程模型的语言。我们在开发进行耗时操作时,比如网络请求会阻塞我们的程序,在Dart中也有并发机制,叫做isolate。APP的启动入口main
函数就是一个类似Android主线程的一个主isolate。和Java的Thread不同的是,Dart中的isolate无法共享内存。
- isolate机制
import 'dart:io';
import 'dart:isolate';
var m;
void main() {
//创建消息接收器
m = 89;//主isolate定义m的值
var receivePort = new ReceivePort();
Isolate.spawn(entryPoint, receivePort.sendPort); //相当于java中开启线程操作
receivePort.listen((t) {
if (t is SendPort) {
t.send("消息2"); // 通过接受子Isolate发出的sendPort来发送消息大主Isolate
} else {
print(t);
}
});
print(message);
}
var message = "hello";
void entryPoint(SendPort sendPort) {
// isolate是内存隔离的,mi的值是在主isolate定义的所以这里获得null
print(m);
sendPort.send("消息1"); //发消息到主Isolate
sleep(Duration(seconds: 10)); //延时10秒打印 消息2
//创建消息接收器
var receivePort2 = new ReceivePort();
receivePort2.listen((t) {
print(t);
});
sendPort.send(receivePort2.sendPort); //发送发送器到主Isolate,实现通信
}
- 任务队列
同Android Handler类似,在Dart运行环境中也是靠事件驱动的,通过event loop不停的从队列中获取消息或者事件来驱动整个应用的运行,isolate发过来的消息就是通过loop处理。但是不同的是在Android中每个线程只有一个Looper所对应的MessageQueue,而Dart中有两个队列,一个叫做event queue(事件队列),另一个叫做microtask queue(微任务队列)。
Dart在执行完main函数后,就会由Loop开始执行两个任务队列中的Event。首先Loop检查微服务队列,依次执行Event,当微服务队列执行完后,就检查Event queue队列依次执行,在执行Event queue的过程中,每执行完一个Event就再检查一次微服务队列。所以微服务队列优先级高,可以利用微服务进行插队。
import 'dart:isolate';
void main() {
var receivePort = new ReceivePort();
receivePort.sendPort.send("消息");
receivePort.listen((t) {
print(t);
});
Future.microtask(() { //优先上面执行
print("微任务队列");
});
}
- Future
在 Dart 库中随处可见 Future 对象,通常异步函数返回的对象就是一个 Future。 当一个 future 执行完后,他里面的值 就可以使用了,可以使用then()
来在 future 完成的时候执行其他代码。Future对象其实就代表了在事件队列中的一个事件的结果。
then()
的返回值同样是一个future对象,可以利用队列的原理进行组合异步任务
List s = ["yuuu", "rtrt", "ewe", "wew"];
Future.forEach(s, (t) {
print(t);
});
new File(r"E:\common\记录(旧).txt").readAsString().then((String s) {
print(s);
});
上面的方式是等待执行完成读取文件之后,再执行一个新的future。如果我们需要等待一组任务都执行完成再统一处理一些事情,可以通过wait()
完成。
Future readDone = new File("/Users/enjoy/a.txt").readAsString();
//延迟3s
Future delayedDone = Future.delayed(Duration(seconds: 3));
Future.wait([readDone, delayedDone]).then((values) {
print(values[0]);//第一个future的结果
print(values[1]);//第二个future的结果
});
- Steam
Stream(流) 在 Dart API 中也经常出现,表示发出的一系列的异步数据。 Stream 是一个异步数据源,它是 Dart 中处理异步事件流的统一 API。
Future 表示稍后获得的一个数据,所有异步的操作的返回值都用 Future 来表示。但是 Future 只能表示一次异步获得的数据。而 Stream 表示多次异步获得的数据。比如 IO 处理的时候,每次只会读取一部分数据和一次性读取整个文件的内容相比,Stream 的好处是处理过程中内存占用较小。而 File 的readAsString()
是一次性读取整个文件的内容进来,虽然获得完整内容处理起来比较方便,但是如果文件很大的话就会导致内存占用过大的问题。
Stream<List<int>> steam = new File(
r"E:\common\记录(旧).txt").openRead();//读取流文件
var file = new File(r"E:\common\apk\20180823\test.txt");
var openWrite = file.openWrite();
openWrite.addStream(steam);//写入流文件
var listen = steam.listen((List<int> bytes) {
print(12131); //执行多次,在文件较大时候每次读取64k的大小
});
listen.onData((_){
print("替代listene");
});
listen.onDone((){
print("结束");
});
listen.onError((e,s){
print("异常");
});
//暂停,如果没有继续则会退出程序
listen.pause();
//继续
listen.resume();
- 广播模式
Stream有两种订阅模式:单订阅和多订阅。单订阅就是只能有一个订阅者,上面的使用我们都是单订阅模式,而广播是可以有多个订阅者。通过 Stream.asBroadcastStream() 可以将一个单订阅模式的 Stream 转换成一个多订阅模式的 Stream,isBroadcast 属性可以判断当前 Stream 所处的模式。
var stream = new File("/Users/enjoy/app-release.apk").openRead();
stream.listen((List<int> bytes) {
});
//错误 单订阅只能有一个订阅者
// stream.listen((_){
// print("stream执行");
// });
var broadcastStream = new File("/Users/enjoy/app-release.apk").openRead().asBroadcastStream();
broadcastStream.listen((_){
print("订阅者1");
});
broadcastStream.listen((_){
print("订阅者2");
});
需要注意的是,多订阅模式如果没有及时添加订阅者则可能丢数据。
//默认是单订阅
var stream = Stream.fromIterable([1, 2, 3]);
//3s后添加订阅者 不会丢失数据
new Timer(new Duration(seconds: 3), () => stream.listen(print));
//创建一个流管理器 对一个stream进行管理
var streamController = StreamController.broadcast();
//添加
streamController.add(1);
//先发出事件再订阅 无法接到通知
streamController.stream.listen((i){
print("broadcast:$i");
});
//记得关闭
streamController.close();
//这里没有丢失,因为stream通过asBroadcastStream转为了多订阅,但是本质是单订阅流,并不改变原始 stream 的实现特性
var broadcastStream = Stream.fromIterable([1, 2, 3]).asBroadcastStream();
new Timer(new Duration(seconds: 3), () => broadcastStream.listen(print));
- async/await
使用async
和await
的代码是异步的,但是看起来很像同步代码。当我们需要获得A的结果,再执行B,时,你需要then()->then()
,但是利用async
与await
能够非常好的解决回调地狱的问题:
//async 表示这是一个异步方法,await必须再async方法中使用
//异步方法只能返回 void和Future
Future<String> readFile() async {
//await 等待future执行完成再执行后续代码
String s= await new File( r"E:\common\记录(旧).txt").readAsString();
String s2 = await new File( r"E:\common\记录(旧).txt").readAsString();
//自动转换为 future
return s;
}