Future
async 库中有一个叫Future的东西。Future是基于观察者模式的。如果你熟悉Rx或者JavaScript的Promises，你就明白了。
简单说，一个Future定义一个未来要发生的事，例如，将来一个值返回给我们。来让我们看看Future实际怎么用。
Future是支持泛型的，例如Future,通过T指定将来返回值的类型。
import 'dart:async';
main(List<String> args) {
getAJoke().then((value) {
print(value);
})
.catchError((error) {
print('Error');
});
}
Future<String> getAJoke() {
return new Future<String>(() {
//Do a long running task. E.g. Network Call.
//Return the result
return "This is a joke";
});
}
getAJoke的函数，返回值为Future<String>.你可以通过new关键字创建一个Future。Future的构造函数，需要一个函数作为参数，这个函数返回T`类型的数据。在匿名函数中的返回值就是Future的返回值。
在main函数中，我们调用了getAJoke方法，他返回Future<String>.我们通过调用then方法订阅Future，在then中注册回调函数，当Future返回值时调用注册函数。同时注册了catchError方法处理在Future执行之间发生的异常。在上面的例子中不会发生异常。
下面的例子是会发生异常的例子。
import 'dart:async';
main(List<String> args) {
getAJoke().then((value) {
print(value);
})
.catchError((error) {
print('Error');
});
}
Future<String> getAJoke() {
return new Future<String>(() {
//Do a long running task. E.g. Network Call.
//Return the result
throw new Exception('No joke for you!');
return "This is a joke";
});
}
现在我们的例子都是会立即返回的，但是在生产环境中都是一些耗时的操作，例如，网络调用，我们可以使用Future.delayed()模仿
import 'dart:async';
main(List<String> args) {
getAJoke().then((value) {
print(value);
})
.catchError((error) {
print('Error');
});
}
Future<String> getAJoke() {
return new Future<String>.delayed(new Duration(milliseconds: 2000),() {
//Do a long running task. E.g. Network Call.
//Return the result
return "This is a joke";
});
}
现在如果你运行，你将需要2秒，才能返回结果。现在看另一个例子。
import 'dart:async';
main(List<String> args) {
getAJoke().then((value) {
print(value);
})
.catchError((error) {
print('Error');
});
print('Another print statement.');
}
Future<String> getAJoke() {
return new Future<String>.delayed(new Duration(milliseconds: 2000),() {
//Do a long running task. E.g. Network Call.
//Return the result
return "This is a joke";
});
}
如上所示，在调用函数之后，我们添加了print语句。在这种场景中，print语句会先执行，之后future的返回值才会打印。这是future的预期行为.但是如果我们希望在执行其他语句之前，先执行future。所以我们需要用到async/await.
例子
void main(){
testFuture();
}
void testFuture() {
Future f = new Future(() => print('f1'));
Future f1 = new Future(() => null);
//Future f1 = new Future.delayed(Duration(seconds: 1) ,() => null);
Future f2 = new Future(() => null);
Future f3 = new Future(() => null);
f3.then((_) => print('f2'));
f2.then((_) {
print('f3');
new Future(() => print('f4'));
f1.then((_) {
print('f5');
});
});
f1.then((m) {
print('f6');
});
print('f7');
}
//打印
f7
f1
f6
f3
f2
f5
f4
import 'dart:async';
void main(){
testScheduleMicrotask();
}
void testScheduleMicrotask(){
scheduleMicrotask(() => print('s1'));
new Future.delayed(new Duration(seconds: 1), () => print('s2'));//因为有延时所以具体执行时间不一定，时间长就最后，时间很短可能在s8后打印
new Future(() => print('s3')).then((_) {
print('s4');
scheduleMicrotask(() => print('s5'));//需要等整个future结束后再去判断Microtask是否有任务
}).then((_) => print('s6'));
new Future(() => print('s7'));
scheduleMicrotask(() => print('s8'));
print('s9');
}
//打印
s9
s1
s8
s3
s4
s6
s5
s7
s2
- 使用new Future将任务加入event队列。
- Future中的then并没有创建新的Event丢到Event Queue中，而只是一个普通的Function Call，在FutureTask执行完后，立即开始执行。
- 如果在then()调用之前Future就已经执行完毕了，那么任务会被加入到microtask队列中，并且该任务会执行then()中注册的回调函数。
- 使用Future.value构造函数的时候，就会上一条一样，创建Task丢到microtask Queue中执行then传入的函数。
- Future.sync构造函数执行了它传入的函数之后，也会立即创建Task丢到microtask Queue中执行。
- 当任务需要延迟执行时，可以使用new Future.delay()来将任务延迟执行。
Async/Await
import 'dart:async';
main(List<String> args) async {
try {
String result = await getAJoke();
print(result);
} catch(e) {
print(e);
}
print('Another print statement.');
}
Future<String> getAJoke() {
return new Future<String>.delayed(new Duration(milliseconds: 2000),() {
//Do a long running task. E.g. Network Call.
//Return the result
return "This is a joke";
});
}
//打印
This is a joke
Another print statement.
如上所示，我们在main函数的花括号开始添加async关键字。我们添加await关键字在调用getAJoke方法之前，他所做的就是在future返回值之后，继续往下执行。我们将整个代码包裹在try-catch中，我们想捕获所有的异常，和之前使用catchError回调是一样。使用awiat关键字，必须给函数添加async关键字，否则没有效果。
例子
import 'dart:async';
main(List<String> args) async {
// async wait
getName1();
getName2();
getName3();
}
// async wait
Future<void> getName1() async {
print('ssss');//可以不用await打断点看下await后的区别
await getStr1(); //遇到第一个await表达式执行暂停，返回future对象，await表达式执行完成后继续执行
await getStr2(); //await表达式可以使用多次
print('getName1');
}
getStr1() {
print('getStr1');
}
getStr2() {
print('getStr2');
}
getName2() {
print('getName2');
}
getName3() {
print('getName3');
}
//打印
ssss
getStr1
getName2
getName3
getStr2
getName1
