Dart多个future队列完成加入顺序关系及原子性论证(dart if)原创

随心笔谈11个月前发布 admin
89 0



目录引言什么是 FutureFuture 操作具备’原子性’吗实验写法一:实验写法二:实验写法三:论证结论

Dart 是一个在单线程中运行的程序。在程序中执行一个需要长时间的执行的操作,为避免卡住UI主线程,我们会用到异步(future),可以使程序在等待一个耗时操作完成时继续处理其他工作。

在进入正题之前,我们先了解一下 Dart 的消息循环机制:

Dart 从两个队列执行任务:Event事件队列Microtask微任务队列事件循环会优先处理微任务队列,microtask清空之后才将 event事件队列中的下一个项目出队并处理事件队列具有来自Dart(Future,Timer,Isolate Message等)和系统(用户输入,I/O等)微任务队列目前仅包含来自Dart,当然我们也可以自己往微队列中插入任务

Future 是什么?这里我们用小篇幅简单描述一下。future是一个异步的执行操作,可以在不阻塞代码的情况下实现耗时功能。

main() {
Future(() {
print(‘我是一个耗时操作’);
}).then((value){
print(‘future 结束了’);
});
print(‘main’);
}

 //打印结果

main

我是一个耗时操作

future 结束了

在项目中,我们使用 、、 相互组合实现异步编码。

上面的篇幅我们说过,future 创建后会被直接加入到事件队列依次执行。那么在上一个 future 在没有标识完成前,下一个 future 可以被执行吗?

小编写了几个样例来做实验:

main() {
Test1.future1().then((value)=> print(value));
Test1.future2().then((value)=> print(value));
}
abstract class Test1 {
static Future<String> future1() async {
return Future(() async {
print(‘开始 future1’);
await TestTool.timeConsume(1000000000); //耗时运算
print(‘一千年过去了’);
return ‘future1 结束了’;
});
}
static Future<String> future2() async {
return Future(() async {
print(‘开始 future2’);
await TestTool.timeConsume(1000); //耗时运算
print(‘继续 future2’);
return ‘future2 结束了’;
});
}
}

 //打印结果

开始 future1

一千年过去了

future1 结束了

开始 future2

继续 future2

future2 结束了

实验结果:

从打印结果上看,future任务没有中断,执行完当前任务后才可执行队列中的下一个future

main() {
Test2.future1().then((value)=> print(value));
Test2.future2().then((value)=> print(value));
}
abstract class Test2 {
static Future<String> future1() async {
print(‘开始 future1’);
await TestTool.timeConsume(1000000000);//耗时运算
print(‘一千年过去了’);
return ‘future1 结束了’;
}
static Future<String> future2() async {
print(‘开始 future2’);
await TestTool.timeConsume(1000);//耗时运算
print(‘继续 future2’);
return ‘future2 结束了’;
}
}

//打印结果

开始 future1

开始 future2

一千年过去了

future1 结束了

继续 future2

future2 结束了

实验结果:

future2future1没有结束前就已经开始了任务。future2会在future1任务执行完成后响应结束,整个过程仍然保持了完成顺序与加入事件队列的顺序一致性。

main() {
Test3.future1().then((value)=> print(value));
Test3.future2().then((value)=> print(value));
}
abstract class Test3 {
static Future<String> future1() async {
print(‘开始 future1’);
await Future(()=> TestTool.timeConsume(1000000000));//耗时运算
print(‘一千年过去了’);
return ‘future1 结束了’;
}
static Future<String> future2() async {
print(‘开始 future2’);
await TestTool.timeConsume(1000);//耗时运算
print(‘继续 future2’);
return ‘future2 结束了’;
}
}

//打印结果

开始 future1

开始 future2

继续 future2

future2 结束了

一千年过去了

future1 结束了

实验结果:

从打印结果上看,future1开始后,future2直接开始任务,且future2任务完成后直接标识完成。future1future2 的完成顺序已经和加入事件队列的顺序无关了,只与内部耗时正相关。

附上耗时代码:

abstract class TestTool {
///耗时操作
static Future<int> timeConsume(int num) async {
final result=_timeConsume(num);
return result;
}
static int _timeConsume(int num) {
int count=0;
while (num > 0) {
if (num % 2==0) {
count++;
}
num–;
}
return count;
}
}

综合上述三种写法分析:

future方法体内部不属于可靠的’原子性操作’,不同的写法有不同的差异性。 如果想将整个方法体内部作为不可拆分的执行单位。在外层使用Future进行包裹处理,如写法一中Test1示例:

static Future<T> funcName() async {
return Future(() async {

具体的方法体内容

return result;
});
}

future在创建的同时,就会被加入到event事件队列中。事件队列是依次执行的,但每个future的完成顺序与加入的顺序不存在可靠的一致性。 如果在业务内想保持顺序的一致性,可参考上述写法,或使用 进行强制等待如:

main() async {
await Test2.future1().then((value)=> print(value));
Test2.future2().then((value)=> print(value));
}

这样写,future2 就一定会在 future1 执行完成后才进入开始状态。

以上就是Dart多个future队列完成加入顺序关系及原子性论证的详细内容,更多关于Dart多个future原子性的资料请关注脚本之家其它相关文章!

您可能感兴趣的文章:Flutter Dart快速排序算法示例详解Flutter基于Dart Unwrapping Multiple Optional小技巧SafeList?in?Flutter?and?Dart小技巧Dart多态控制反转编码规范实例详解Dart?异步编程生成器及自定义类型用法详解Dart语法之变量声明与数据类型实例详解Flutter入门学习Dart语言变量及基本使用概念一文详解Dart如何实现多任务并行

© 版权声明

相关文章