Flutter 是 Google 开源的 UI 工具包,帮助开发者通过一套代码库高效构建多平台精美应用,Flutter 开源、免费,拥有宽松的开源协议,支持移动、Web、桌面和嵌入式平台。
Flutter是使用Dart语言开发的跨平台移动UI框架,通过自建绘制引擎,能高性能、高保真地进行Android和IOS开发。Flutter采用Dart语言进行开发,而并非Java,Javascript这类热门语言,这是Flutter团队对当前热门的10多种语言慎重评估后的选择。因为Dart囊括了多数编程语言的优点,它更符合Flutter构建界面的方式。
本文主要就是简单梳理一下Dart语言的一些基础知识和语法。关于编程语言的基本语法无外乎那么些内容,注释、变量、数据类型、运算符、流程控制、函数、类、异常、文件、异步、常用库等内容,相信大部分读者都是有一定编程基础的,所以本文就简单地进行一个梳理,不做详细的讲解。大家也可以参考 Dart编程语言中文网。
上一篇文章主要是写了Dart语言的类和对象、泛型以及库的使用,本文将接着上一篇文章继续往后写,本文将主要介绍Dart语言中的异步。关于Dart中的异步,本文主要内容来源于官网链接https://dart.dev/codelabs/async-await,官网基本都是英文的,所以本文转载自 Flutter(五)之彻底搞懂Dart异步,该博文中的内容基本与官网中介绍的一致。
我们先来搞清楚Dart是如何搞定异步操作的
开发中的耗时操作:
如何处理耗时的操作呢?
我之前碰到很多开发者都对单线程的异步操作充满了问号???
其实它们并不冲突:
阻塞式调用和非阻塞式调用
如果想搞懂这个点,我们需要知道操作系统中的阻塞式调用
和非阻塞式调用
的概念。
我们用一个生活中的例子来模拟:
外卖的动作
就是我们的调用,拿到最后点的外卖
就是我们要等待的结果。而我们开发中的很多耗时操作,都可以基于这样的 非阻塞式调用
:
非阻塞方式的工作
;基于事件的回调机制
;这些操作都不会阻塞我们单线程的继续执行,我们的线程在等待的过程中可以继续去做别的事情:喝杯咖啡、打把游戏,等真正有了响应,再去进行对应的处理即可。
这时,我们可能有两个问题:
单线程模型中主要就是在维护着一个事件循环(Event Loop)。
事件循环是什么呢?
我们来写一个事件循环的伪代码:
// 这里我使用数组模拟队列, 先进先出的原则
List eventQueue = [];
var event;
// 事件循环从启动的一刻,永远在执行
while (true) {
if (eventQueue.length > 0) {
// 取出一个事件
event = eventQueue.removeAt(0);
// 执行该事件
event();
}
}
当我们有一些事件时,比如点击事件、IO事件、网络事件时,它们就会被加入到eventLoop
中,当发现事件队列不为空时发现,就会取出事件,并且执行。
这里我们来看一段伪代码,理解点击事件和网络请求的事件是如何被执行的:
RaisedButton(
child: Text('Click me'),
onPressed: () {
final myFuture = http.get('https://example.com');
myFuture.then((response) {
if (response.statusCode == 200) {
print('Success!');
}
});
},
)
这些代码是如何放在事件循环中执行呢?
尽管onPressed和then中的回调有一些差异,但是它们对于事件循环来说,都是告诉它:我有一段代码需要执行,快点帮我完成。
我思考了很久,这个Future到底应该如何讲解
我们先来看一个例子吧:
import "dart:io";
main(List<String> args) {
print("main function start");
print(getNetworkData());
print("main function end");
}
String getNetworkData() {
sleep(Duration(seconds: 3));
return "network data";
}
这段代码会运行怎么的结果呢?
main function start
// 等待3秒
network data
main function end
显然,上面的代码不是我们想要的执行效果,因为网络请求阻塞了main函数,那么意味着其后所有的代码都无法正常的继续执行。
我们来对我们上面的代码进行改进,代码如下:
import "dart:io";
main(List<String> args) {
print("main function start");
print(getNetworkData());
print("main function end");
}
Future<String> getNetworkData() {
return Future<String>(() {
sleep(Duration(seconds: 3));
return "network data";
});
}
我们来看一下代码的运行结果:
main function start
Instance of 'Future<String>'
main function end
获取Future得到的结果
有了Future之后,如何去获取请求到的结果:通过.then的回调:
main(List<String> args) {
print("main function start");
// 使用变量接收getNetworkData返回的future
var future = getNetworkData();
// 当future实例有返回结果时,会自动回调then中传入的函数
// 该函数会被放入到事件循环中,被执行
future.then((value) {
print(value);
});
print(future);
print("main function end");
}
上面代码的执行结果:
main function start
Instance of 'Future<String>'
main function end
// 3s后执行下面的代码
network data
执行中出现异常
如果调用过程中出现了异常,拿不到结果,如何获取到异常的信息呢?
import "dart:io";
main(List<String> args) {
print("main function start");
var future = getNetworkData();
future.then((value) {
print(value);
}).catchError((error) { // 捕获出现异常时的情况
print(error);
});
print(future);
print("main function end");
}
Future<String> getNetworkData() {
return Future<String>(() {
sleep(Duration(seconds: 3));
// 不再返回结果,而是出现异常
// return "network data";
throw Exception("网络请求出现错误");
});
}
上面代码的执行结果:
main function start
Instance of 'Future<String>'
main function end
// 3s后没有拿到结果,但是我们捕获到了异常
Exception: 网络请求出现错误
补充一:上面案例的小结
我们通过一个案例来学习了一些Future的使用过程:
补充二:Future的两种状态
事实上Future在执行的整个过程中,我们通常把它划分成了两种状态:
未完成状态(uncompleted)
Dart官网有对这两种状态解析,之所以贴出来是区别于Promise的三种状态
补充三:Future的链式调用
上面代码我们可以进行如下的改进:
import "dart:io";
main(List<String> args) {
print("main function start");
getNetworkData().then((value1) {
print(value1);
return "content data2";
}).then((value2) {
print(value2);
return "message data3";
}).then((value3) {
print(value3);
});
print("main function end");
}
Future<String> getNetworkData() {
return Future<String>(() {
sleep(Duration(seconds: 3));
// 不再返回结果,而是出现异常
return "network data1";
});
}
打印结果如下:
main function start
main function end
// 3s后拿到结果
network data1
content data2
message data3
补充四:Future其他API
Future.value(value):
直接获取一个完成的Future,该Future会直接调用then的回调函数 哈哈哈
是在最后打印的呢?这是因为Future中的then会作为新的任务会加入到事件队列中(Event Queue),加入之后你肯定需要排队执行了
main(List<String> args) {
print("main function start");
Future.value("哈哈哈").then((value) {
print(value);
});
print("main function end");
}
// 打印结果如下:
main function start
main function end
哈哈哈
Future.error(object):
直接获取一个完成的Future,但是是一个发生异常的Future,该Future会直接调用catchError的回调函数 main(List<String> args) {
print("main function start");
Future.error(Exception("错误信息")).catchError((error) {
print(error);
});
print("main function end");
}
// 打印结果如下:
main function start
main function end
Exception: 错误信息
Future.delayed(时间, 回调函数)
main(List<String> args) {
print("main function start");
Future.delayed(Duration(seconds: 3), () {
return "3秒后的信息";
}).then((value) {
print(value);
});
print("main function end");
}
如果你已经完全搞懂了Future,那么学习await、async应该没有什么难度。
await、async是什么呢?
同步的代码格式
,去实现异步的调用过程
。我们已经知道,Future可以做到不阻塞我们的线程,让线程继续执行,并且在完成某个操作时改变自己的状态,并且回调then或者errorCatch回调。
如何生成一个Future呢?
Talk is cheap. Show me the code.
我们来对之前的Future异步处理代码进行改造,改成await、async的形式。
我们知道,如果直接这样写代码,代码是不能正常执行的:
"network data"
去使用import "dart:io";
main(List<String> args) {
print("main function start");
print(getNetworkData());
print("main function end");
}
String getNetworkData() {
var result = Future.delayed(Duration(seconds: 3), () {
return "network data";
});
return "请求到的数据:" + result;
}
现在我使用await修改下面这句代码:
Future.delayed
函数前加了一个await。Future.delayed
的执行完毕,并且等待它的结果。修改后执行代码,会看到如下的错误:
getNetworkData
函数定义成async函数。继续修改代码如下:也非常简单,只需要在函数的()后面加上一个async关键字就可以了
String getNetworkData() async {
var result = await Future.delayed(Duration(seconds: 3), () {
return "network data";
});
return "请求到的数据:" + result;
}
运行代码,依然报错(心想:你妹啊):
继续修改代码如下:
Future<String> getNetworkData() async {
var result = await Future.delayed(Duration(seconds: 3), () {
return "network data";
});
return "请求到的数据:" + result;
}
这段代码应该是我们理想当中执行的代码了
我这里给出了一个在Flutter项目中,读取一个本地的json文件,并且转换成模型对象,返回出去的案例;这个案例作为大家学习前面Future和await、async的一个参考,我并不打算展开来讲,因为需要用到Flutter的相关知识;后面我会在后面的案例中再次讲解它在Flutter中我使用的过程中;
// 读取json案例代码(了解一下即可)
import 'package:flutter/services.dart' show rootBundle;
import 'dart:convert';
import 'dart:async';
main(List<String> args) {
getAnchors().then((anchors) {
print(anchors);
});
}
class Anchor {
String nickname;
String roomName;
String imageUrl;
Anchor({
this.nickname,
this.roomName,
this.imageUrl
});
Anchor.withMap(Map<String, dynamic> parsedMap) {
this.nickname = parsedMap["nickname"];
this.roomName = parsedMap["roomName"];
this.imageUrl = parsedMap["roomSrc"];
}
}
Future<List<Anchor>> getAnchors() async {
// 1.读取json文件
String jsonString = await rootBundle.loadString("assets/yz.json");
// 2.转成List或Map类型
final jsonResult = json.decode(jsonString);
// 3.遍历List,并且转成Anchor对象放到另一个List中
List<Anchor> anchors = new List();
for (Map<String, dynamic> map in jsonResult) {
anchors.add(Anchor.withMap(map));
}
return anchors;
}
在前面学习学习中,我们知道Dart中有一个事件循环(Event Loop)来执行我们的代码,里面存在一个事件队列(Event Queue),事件循环不断从事件队列中取出事件执行。
但是如果我们严格来划分的话,在Dart中还存在另一个队列:微任务队列(Microtask Queue)。
事件循环
都是优先执行微任务队列
中的任务,再执行 事件队列
中的任务;那么在Flutter开发中,哪些是放在事件队列,哪些是放在微任务队列呢?
说道这里,你可能已经有点凌乱了,在Dart的单线程中,代码到底是怎样执行的呢?
main函数中的代码
会优先执行;微任务队列(Microtask Queue)
中的所有任务;事件队列(Event Queue)
中的所有任务;在开发中,我们可以通过dart中async下的scheduleMicrotask来创建一个微任务:
import "dart:async";
main(List<String> args) {
scheduleMicrotask(() {
print("Hello Microtask");
});
}
在开发中,如果我们有一个任务不希望它放在Event Queue中依次排队,那么就可以创建一个微任务了。
Future的代码是加入到事件队列还是微任务队列呢?
Future中通常有两个函数执行体:
那么它们是加入到什么队列中的呢?
// future_1加入到eventqueue中,紧随其后then_1被加入到eventqueue中
Future(() => print("future_1")).then((_) => print("then_1"));
// Future没有函数执行体,then_2被加入到microtaskqueue中
Future(() => null).then((_) => print("then_2"));
// future_3、then_3_a、then_3_b依次加入到eventqueue中
Future(() => print("future_3")).then((_) => print("then_3_a")).then((_) => print("then_3_b"));
我们根据前面的规则来学习一个极的代码执行顺序
案例:
import "dart:async";
main(List<String> args) {
print("main start");
Future(() => print("task1"));
final future = Future(() => null);
Future(() => print("task2")).then((_) {
print("task3");
scheduleMicrotask(() => print('task4'));
}).then((_) => print("task5"));
future.then((_) => print("task6"));
scheduleMicrotask(() => print('task7'));
Future(() => print('task8'))
.then((_) => Future(() => print('task9')))
.then((_) => print('task10'));
print("main end");
}
// 代码执行的结果是:
main start
main end
task7
task1
task6
task2
task3
task5
task4
task8
task9
task10
代码分析:
main start
和main end
先执行,没有任何问题;过程中
,会将一些任务分别加入到EventQueue
和MicrotaskQueue
中;scheduleMicrotask
函数调用,所以它被最早加入到MicrotaskQueue
,会被先执行;EventQueue
,task1被添加到EventQueue
中被执行;final future = Future(() => null);
创建的future的then被添加到微任务中,微任务直接被优先执行,所以会执行task6;EventQueue
中添加task2、task3、task5被执行;scheduleMicrotask
,那么在执行完这次的EventQueue
后会执行,所以在task5后执行task4(注意:scheduleMicrotask
的调用是作为task3的一部分代码,所以task4是要在task5之后执行的)EventQueue
被执行;事实上,上面的代码执行顺序有可能出现在面试中,我们开发中通常不会出现这种复杂的嵌套,并且需要完全搞清楚它的执行顺序;
但是,了解上面的代码执行顺序,会让你对EventQueue
和microtaskQueue
有更加深刻的理解。
在Dart中,有一个Isolate的概念,它是什么呢?
在 Isolate 中,资源隔离做得非常好,每个 Isolate 都有自己的 Event Loop 与 Queue,
但是,如果只有一个Isolate,那么意味着我们只能永远利用一个线程,这对于多核CPU来说,是一种资源的浪费。
如果在开发中,我们有非常多耗时的计算,完全可以自己创建Isolate,在独立的Isolate中完成想要的计算操作。
如何创建Isolate呢?
创建Isolate是比较简单的,我们通过Isolate.spawn
就可以创建了:
import "dart:isolate";
main(List<String> args) {
Isolate.spawn(foo, "Hello Isolate");
}
void foo(info) {
print("新的isolate:$info");
}
但是在真实开发中,我们不会只是简单的开启一个新的Isolate,而不关心它的运行结果:
import "dart:isolate";
main(List<String> args) async {
// 1.创建管道
ReceivePort receivePort= ReceivePort();
// 2.创建新的Isolate
Isolate isolate = await Isolate.spawn<SendPort>(foo, receivePort.sendPort);
// 3.监听管道消息
receivePort.listen((data) {
print('Data:$data');
// 不再使用时,我们会关闭管道
receivePort.close();
// 需要将isolate杀死
isolate?.kill(priority: Isolate.immediate);
});
}
void foo(SendPort sendPort) {
sendPort.send("Hello World");
}
但是我们上面的通信变成了单向通信,如果需要双向通信呢?
compute
函数,它内部封装了Isolate的创建和双向通信;注意:下面的代码不是dart的API,而是Flutter的API,所以只有在Flutter项目中才能运行
main(List<String> args) async {
int result = await compute(powerNum, 5);
print(result);
}
int powerNum(int num) {
return num * num;
}