Flutter异步编程指南

原副标题：Flutter触发器程式设计手册

译者 | 天猫云合作开发人员-天猫仓储 字用章

1 Dart 中的该事件循环式数学模型

在 App 合作开发中，时常会碰到处置触发器各项任务的情景，如互联网允诺、随机存取文件等。Android、iOS 使用的是多处理器，而在 Flutter 中为Renderscript该事件循环式，如下表所示图右图

Dart 三个各项任务堆栈，分别为 microtask 堆栈和 event 堆栈，堆栈中的各项任务按照先进先出的次序继续执行，而 microtask 堆栈的继续执行错误率低于 event 堆栈。在 main 方式继续执行完后，会开启该事件循环式，首先将 microtask 堆栈中的各项任务逐一继续执行完，再去继续执行 event 堆栈中的各项任务，每三个 event 堆栈中的各项任务在继续执行完成后，会再去优先选择继续执行 microtask 堆栈中的各项任务，如此反反复复，直至移走所有堆栈，那个过程就是 Dart 该事件循环式的处置监督机制。这种监督机制能让我们更单纯的处置触发器各项任务，不必害怕锁的问题。他们能很容易的预估各项任务继续执行的次序，但无法精确的预估到该事件循环式何时能会处置到你期许继续执行的各项任务。比如建立了三个延时各项任务，但排在后面的各项任务结束前是不能处置那个延时任务的，也就说那个各项任务的等候时间可能会小于选定的延时。

Dart 中的方式除非开始继续执行就不能被吓倒，而 event 堆栈中的该事件还源自于使用者输出、IO、计时器、绘出等，这意味著在三个堆栈中都不适宜继续执行排序速度慢的各项任务，才能确保简洁的 UI 绘出和使用者该事件的加速积极响应。而且当三个各项任务的标识符发生极度时，只会吓倒当前各项任务，先期各项任务不受负面影响，流程更不能选择退出。从上图还能窥见，将三个各项任务重新加入 microtask 堆栈，能提高各项任务错误率，但是一般不建议这么做，假如比较即时的各项任务并且排序量并不大，因为 UI 绘出和处置使用者该事件是在 event 该事件堆栈中的，误用 microtask 堆栈可能会负面影响使用者新体验。

总结下 Dart 该事件循环式的主要基本概念：

能使用顶层方式 scheduleMicrotask 或者 Future.microtask 方式，如下表所示右图：

scheduleMicrotask(=> print( microtask1));

Future.microtask( => print( microtask2));

使用 Future.microtask 的优势在于能在 then 回调中处置各项任务返回的结果。

1.2 向 event 堆栈中添加各项任务Future( => print( event task));

基于以上理论，通过如下表所示标识符能验证 Dart 的该事件循环式监督机制：

void main {

print( main start);

Future( => print( event task1));

Future.microtask( => print( microtask1));

Future( => print(event task1));

Future.microtask( => print( microtask2));

print( main stop);

继续执行结果：

main start

mainstop

microtask1

microtask2

eventtask1

eventtask1

通过输出结果能看到，各项任务的继续执行次序并不是按照编写标识符的次序来的，将各项任务添加到堆栈不能立刻继续执行，而继续执行次序也完全符合后面讲的规则，当前 main 方式中的标识符继续执行完后，才会去继续执行堆栈中的各项任务，且 microTask 堆栈的错误率低于 event 堆栈。

2 Dart 中的触发器实现

在 Dart 中通过 Future 来继续执行触发器各项任务， Future 是对触发器各项任务状态的封装，对各项任务结果的代理，通过 then 方式能注册处置各项任务结果的回调方式。

建立方式 Future 方式：

Future

Future.delayed

Future.microtask

Future.sync

2.1 Futurefactory Future(FutureOr<T> computation) {

_Future<T> result = new_Future<T>;

Timer.run( {

try{

result._complete(computation);

} catch(e, s) {

_completeWithErrorCallback(result, e, s);

}

});

returnresult;

}

上面是 Future 的源码，能看到内部是通过开启三个没有延迟的计时器来添加各项任务的，实用 try catch 来捕获各项任务标识符中可能出现的极度，他们能在 catchError 回调中来处置极度。

2.2 Future.delayedfactory Future.delayed(Duration duration, [ FutureOr<T> computation?]) {

if(computation == null&& !typeAcceptsNull<T>) {

throwArgumentError. value( null, “computation”, “The type parameter is not nullable”);

}

_Future<T> result = new_Future<T>;

newTimer(duration, {

if(computation == null) {

result._complete( nullasT);

} else{

try{

result._complete(computation);

} catch(e, s) {

_completeWithErrorCallback(result, e, s);

}

}

});

returnresult;

}

Future.delayed 与 Future 的区别是通过三个延迟的计时器来添加各项任务。

2.3 Future.microtaskfactory Future.microtask( FutureOr<T> computation) {

_Future<T> result = new_Future<T>;

scheduleMicrotask( {

try{

result._complete(computation);

} catch(e, s) {

_completeWithErrorCallback(result, e, s);

}

});

returnresult;

}

Future.microtask 是将各项任务添加到 microtask 堆栈，通过这种能很方便通过 then 方式中的回调来处置各项任务的结果。

2.4 Future.syncfactory Future.sync( FutureOr<T> computation) {

try{

varresult = computation;

if(result isFuture<T>) {

returnresult;

} else{

// TODO(40014): Remove cast when type promotion works.

returnnew_Future<T>. value(resultasdynamic);

}

} catch(error, stackTrace) {

varfuture = new_Future<T>;

AsyncError? replacement = Zone.current.errorCallback(error, stackTrace);

if(replacement != null) {

future._asyncCompleteError(replacement.error, replacement.stackTrace);

} else{

future._asyncCompleteError(error, stackTrace);

}

returnfuture;

}

}

Future.sync 中的各项任务会被立即继续执行，不能添加到任何堆栈。

在第三个章节中讲到了能很容易的预估各项任务的继续执行次序，下面他们通过三个例子来验证：

void main {

print( main start);

Future.microtask( => print( microtask1));

Future.delayed( newDuration(seconds: 1), => print( delayed event));

Future( => print( event1));

Future( => print( event2));

Future.microtask( => print( microtask2));

print( main stop);

}

继续执行结果：

main start

mainstop

microtask1

microtask2

event1

event2

delayedevent

因为标识符比较单纯，通过标识符能很容易的预估到继续执行结果，下面将复杂度稍微提高。

void main {

print( main start);

Future.microtask( => print( microtask1));

Future.delayed( newDuration(seconds:1), => print( delayed event));

Future( => print( event1))

. then( (_)=> print( event1 – callback1))

. then( (_)=> print( event1 – callback2));

Future( => print( event2)). then((_) {

print( event2 – callback1);

returnFuture( => print( event4)). then( (_)=> print( event4 – callback));

}). then((_) {

print( event2 – callback2);

Future( => print( event5)). then( (_)=> print( event5 – callback));

}). then((_) {

print( event2 – callback3);

Future.microtask( => print( microtask3));

}). then((_) {

print( event2 – callback4);

});

Future( => print( event3));

Future.sync( => print( sync task));

Future.microtask( => print( microtask2)). then( (_)=> print( microtask2 – callbak));

print( main stop);

}

继续执行结果：

mainstart

synctask

mainstop

microtask1

microtask2

microtask2– callbak

event1

event1– callback1

event1– callback2

event2

event2– callback1

event3

event4

event4– callback

event2– callback2

event2– callback3

event2– callback4

microtask3

event5

event5– callback

delayedevent

看到结果后你可能会疑惑，为什么 event1、event1 – callback1、event1 – callback2 会连续输出，而 event2 – callback1 输出后为什么是 event3，event5、event5 – callback 为什么会在 microtask3 后输出？

这里他们补充下 then 方式的一些关键知识，理解了这些，上面的输出结果也就很好理解了：

throw error;

}). then((_) {

print( success);

}).catchError(( error) {

print( error);

}).whenComplete( {

print( completed);

});

输出结果：

error

completed

通过 catchError 方式注册的回调，能用来处置各项任务标识符产生的极度。不管 Future 中的各项任务继续执行成功与否，whenComplete 方式都会被调用。

2.6 async、await

使用 async、await 能以更简洁的编写触发器标识符，是 Dart 提供的三个语法糖。使用 async 关键字修饰的方式返回值类型为 Future，在 async 方式内能使用 await 关键字来修饰触发器各项任务，在方式内部达到同步继续执行的效果，能达到简化标识符和提高可读性的效果，不过如果想要处置极度，需要实用 try catch 语句来包裹 await 修饰的触发器各项任务。

void main async {

print( awaitgetData);

}

Future<int> getData async {

final a = awaitFuture.delayed(Duration(seconds:1), => 1);

final b = awaitFuture.delayed(Duration(seconds: 1), => 1);

returna + b;

} 3 Isolate 介绍

后面讲到耗时各项任务不适宜放到 microtask 堆栈或 event 堆栈中继续执行，会导致 UI 卡顿。那么在 Flutter 没有既能继续执行耗时各项任务又不负面影响 UI 绘出呢，其实是有的，后面提到 microtask 堆栈和 event 堆栈是在 main isolate 中运行的，而 isolate 是在线程中运行的，那他们开启三个新的 isolate 就能了，相当于开启三个新的线程，使用多处理器的方式来继续执行各项任务，Flutter 也为他们提供了相应的 Api。

3.1 computevoidmain async{

compute< String, String>(

getData,

Alex,

).then((result) {

print(result);

});

}

StringgetData( Stringname) {

// 模拟耗时3秒

sleep(Duration(seconds: 3));

returnHello $name;

}

compute 第三个参数是要继续执行的各项任务，第二个参数是要向各项任务发送的消息，需要注意的是第三个参数只支持顶层参数。使用 compute 能方便的继续执行耗时各项任务，但是误用的话也会适得其反，因为每次调用，相当于新建三个 isolate。上面的标识符继续执行三个经历了 isolate 的建立以及销毁过程，还有数据的传递会经历两次拷贝，因为 isolate 之间是完全隔离的，不能共享内存，整个过程除去各项任务本身的继续执行时间，也会非常的耗时，isolate 的建立也比较消耗内存，建立过多的 isolate 还有 OOM 的风险。这时他们就需要三个更优的解决方案，减少频繁建立销毁 isolate 所带来的消耗，最好是能建立三个类似于线程池的东西，只要提前初始化好，后面就能随时使用，不必害怕会发生后面所讲的问题，这时候 LoadBalancer 就派上用场了

3.2 LoadBalancer// 用来建立 LoadBalancer

Future<LoadBalancer> loadBalancerCreator = LoadBalancer.create( 2, IsolateRunner.spawn);

// 全局可用的 loadBalancer

late LoadBalancer loadBalancer;

void main async{

// 初始化 LoadBalancer

loadBalancer =awaitloadBalancerCreator;

// 使用 LoadBalancer 继续执行各项任务

finalresult = awaitloadBalancer.run< String, String>(getData, Alex);

print(result);

}

StringgetData( Stringname) {

// 模拟耗时3秒

sleep(Duration(seconds: 3));

returnHello$name;

}

使用 LoadBalancer.create 方式能建立出三个 isolate 线程池，能够选定 isolate 的数量，并自动实现了负载均衡。应用开启后在合适的时机将其初始化好，先期就有三个全局可用的 LoadBalancer 了。

4 实用经验4.1 选定各项任务的继续执行次序

在合作开发中时常会有需要连续继续执行触发器各项任务的情景，比如下表所示面的例子，后面的一步各项任务直接需要以来后面任务的结果，所有各项任务正常继续执行完才算成功。

voidmainasync{

print( awaitgetData);

}

Future< int> getData{

final completer = Completer<int>;

intvalue= 0;

Future( {

return1;

}).then((result1) {

value+= result1;

returnFuture( {

return2;

}).then((result2) {

value+= result2;

returnFuture( {

return3;

}).then((result3) {

value+= result3;

completer.complete(value);

});

});

});

returncompleter.future;

}

这种方式出现了回调地狱，标识符非常难以阅读，实际合作开发中还会有处置极度的标识符，会显得更加臃肿，编写难度也大，显然这种方式是不建议使用的。

4.2 使用 then 的链式调用voidmainasync{

print( awaitgetData);

}

Future< int> getData{

intvalue= 0;

returnFuture( =>1).then((result1) {

value+= result1;

returnFuture( => 2);

}).then((result2) {

value+= result2;

returnFuture( => 3);

}).then((result3) {

value+= result3;

returnvalue;

});

}

回调地狱的问题解决了，标识符可读性提高很多。

4.3 使用 async、awaitvoidmainasync{

print( awaitgetData);

}

Future< int> getDataasync{

intvalue= 0;

value+= awaitFuture( => 1);

value+= awaitFuture( => 2);

value+= awaitFuture( => 3);

returnvalue;

}

效果显而易见，标识符更加清晰了。

4.4 取消各项任务

在后面讲到了 Dart 方式继续执行时是不能被中断的，这就意味著三个 Future 各项任务开始后必然会走到完成的状态，但是很多时候他们需要又取消三个触发器各项任务，唯一的办法就是在各项任务结束后不继续执行回调标识符，就能实现类似取消的效果。

4.5 CancelableOperation

在 Flutter 的 async 包中，提供了三个 CancelableOperation 给他们使用，使用它能很单纯的实现取消各项任务的需求。

voidmainasync{

// 建立三个能取消的各项任务

final cancelableOperation = CancelableOperation.fromFuture(

Future( async{

print( start);

awaitFuture.delayed(Duration(seconds: 3)); // 模拟耗时3秒

print( end);

}),

onCancel: => print( cancel…),

);

// 注册各项任务结束后的回调

cancelableOperation.value.then((val) {

print( finished);

});

// 模拟1秒后取消各项任务

Future.delayed(Duration(seconds:1)).then( ( _) => cancelableOperation.cancel);

}

CancelableOperation 是对 Future 的代理， 对 Future 的 then 进行了接管，判断 isCanceled 标记决定是否需要继续执行使用者提供的回调。

16款开源的全文搜索引擎 中兴新支点OS桌面环境正式开源，仅104M，速度提升20% Slint 1.0正式发布，Rust编写的原生GUI工具包

🌟 活动推荐

2023 年 5 月 27-28 日，GOTC 2023 全球开源技术峰会将在上海张 江科学会堂隆重举行。

为期 2 天的开源行业盛会，将以行业展览、主题发言、特别论坛、分论坛、快闪演讲的形式来诠释此次大会主题 ——“Open Source, Into the Future”。与会者将一起探讨元宇宙、3D 与游戏、eBPF、Web3.0、区块链等热门技术主题，以及 OSPO、汽车软件、AIGC、开源教育培训、云原生、信创等热门话题，探讨开源未来，助力开源发展。