Dart 是单线程语言,开发种进行耗时操作（如：网络请求、数据库存储、文件读取）时会阻塞程序。可以用 Future、async、await 把耗时的事件异步执行操作，但如果是执行大量耗时同步操作的话，应该使用isolate开辟新的线程去执行。

Future

Future<T> 类，是个泛型类，可以指定类型。如果没有指定，则 Future 会执行动态的推导类型。表示一个 T 类型的异步操作结果。如果异步操作不需要结果，则类型为 Future<void>。

Future.value()

创建一个返回指定value值的Future

import 'dart:async'

void main() {
  futureValueTest();
  print('4-做其他事情');
}

void futureValueTest() async {
  var future = await Future.value(1);
  print(future);
}

运行结果：
flutter: 4-做其他事情
flutter: 1

Future.delay()

创建一个延迟执行的Future，并且返回Future对象。

void main() {
  futterDelayTest();
  print('4-做其他事情');
}

void futterDelayTest() {
  Future.delayed(Duration(seconds: 3), () {
    print("延时3秒执行");
  });
}

运行结果：
flutter: 4-做其他事情
flutter: 延时3秒执行

Future 中实现的延时操作通过Timer来实现的，在实际开发中，如果只是一个单纯的延时操作，建议使用Timer

void main() {
  timerTest();
  print('4-做其他事情');
}

void timerTest() {
  Timer timer = new Timer(Duration(seconds: 3), () {
    print("延时3秒执行");
  });
}

运行结果：
flutter: 4-做其他事情
flutter: 延时3秒执行

Future的结果处理

Future 提供了下面三个方法来处理结果

Future<R> then<R>(FutureOr<R> onValue(T value), {Function onError});
Future<T> catchError(Function onError, {bool test(Object error)});
Future<T> whenComplete(FutureOr action());

一个 Future 只会对应一个结果，要么成功，要么失败。成功了执行成功的操作，失败了就捕获错误。

Future.then()

用来注册一个 Future 完成时要调用的回调，并且返回一个Future对象。

void main() {
  Future(() => print('A')).then((value) => print('A结束'));
  Future(() => print('B')).then((value) => print('B结束'));
}

运行结果：
flutter: A
flutter: A结束
flutter: B
flutter: B结束

如果 Future 有多个 then()，它们会按照链接的先后顺序同步执行，并共用一个 event loop；
then() 比 Future 默认的队列优先级高，then() 会在 Future 函数体执行完毕后立刻执行。

Future.catchError()

用来注册一个捕捉 Future 的错误的回调，并且返回一个 Future 对象

then() 在 catchError() 前使用

String _data = '0';

void main() {
  getData3();
  print('4-做其他事情');
}

void getData3() async {
  print('1-开始data=$_data');
  
  Future(() {
    for (int i = 0; i < 100000000; i++) {
      _data = '网络数据';
      throw Exception('网络异常');
    }
    print('1-结束data=$_data');
  }).then((value) {
    print('处理业务');
  }).catchError((e) {
    print('捕获异常');
  });

  print('2-结束data=$_data');
}

运行结果：
flutter: 1-开始data=0
flutter: 2-结束data=0
flutter: 4-做其他事情
flutter: 捕获异常

then() 在 catchError() 后使用

String _data = '0';

void main() {
  getData3();
  print('4-做其他事情');
}

void getData4() async {
  print('1-开始data=$_data');
  
  Future(() {
    for (int i = 0; i < 100000000; i++) {
      _data = '网络数据';
      throw Exception('网络异常');
    }
    print('1-结束data=$_data');
  }).catchError((e) {
    print('捕获异常');
  }).then((value) {
    print('处理业务');
  });

  print('2-结束data=$_data');
}

运行结果：
flutter: 1-开始data=0
flutter: 2-结束data=0
flutter: 4-做其他事情
flutter: 捕获异常
flutter: 处理业务

区别就是：then() 在 catchError() 后使时用，会走处理业务的回调

Future.catchError 和 then() 中回调 onError

Future.catchError回调只处理原始 Future 抛出的错误，不能处理回调函数抛出的错误，此时可以使用then()的回调onError：

void main() {
  getData5();
  print('4-做其他事情');
}

void getData5() async {
  Future(() {
    throw Exception('error1');
  }).catchError((e) {
    print(e);
    throw Exception('error2');
  }).then(print, onError: (error) {
    print(error);
  });
}

运行结果：
flutter: 4-做其他事情
flutter: Exception: error1
flutter: Exception: error2

Future.whenComplete()

不管是错误导致还是正常执行完毕， whenComplete() 总会被调用，并且返回一个 Future 对象

void main() {
  Future(() {
    throw '发生错误';
  }).then(print).catchError(print).whenComplete(() => print('whenComplete'));

  Future(() {
    return '没有错误';
  }).then(print).catchError(print).whenComplete(() => print('whenComplete'));
}

运行结果：
flutter: 发生错误
flutter: whenComplete
flutter: 没有错误
flutter: whenComplete

Future.wait()

开发中会遇到这样的场景：网络请求 A 和 B 都完成后，再执行代码C，此时可以使用Future.wait() 。Future.wait() 会等待多个 Future 完成收集它们的结果。

所有 Future 都有正常结果返回

void main() {
  futureWaitTest();
  print('4-做其他事情');
}

void futureWaitTest() {
  var future1 = new Future(() => '任务1');
  var future2 = new Future(() => '任务2');
  var future3 = new Future(() => '任务3');
  Future.wait([future1, future2, future3]).then(print).catchError(print);
  print('任务添加完毕');
}

运行结果：
flutter: 任务添加完毕
flutter: 4-做其他事情
flutter: [任务1, 任务2, 任务3]

一个或者几个 Future 发生错误，则 Future 的返回结果是第一个发生错误的 Future 的值：

void main() {
  futureWaitTest();
  print('4-做其他事情');
}

void futureWaitTest() {
  var future1 = new Future(() => '任务1');
  var future2 = new Future(() => throw throw Exception('任务2异常'));
  var future3 = new Future(() => '任务3');
  Future.wait([future1, future2, future3]).then(print).catchError(print);
  print('任务添加完毕');
}

运行结果：
flutter: 任务添加完毕
flutter: 4-做其他事情
flutter: Exception: 任务2异常

Future.timeout()

开发中会遇到这样的场景：网络请求 A 超过 30 秒后抛出超时异常

void main() {
  futureTimeoutTest();
  print('4-做其他事情');
}

void futureTimeoutTest() {
  Future.delayed(Duration(seconds: 50), () {
    return '网络请求50秒';
  }).timeout(Duration(seconds: 30)).then(print).catchError(print);
}

运行结果：
flutter: 4-做其他事情
flutter: TimeoutException after 0:00:03.000000: Future not completed

async、await

async-await 本质上是对 Future API 的简化形式，将异步回调代码写成同步代码结构形式

async：表示函数是异步的，定义的函数会返回一个 Future 对象
await：await 只能出现在 async 标记的异步函数内，后面跟着一个 Future，表示等待该异步任务完成后才会继续往下执行。

async和await只会作用于当前函数，并不会对其他外部函数造成执行上的影响

main() {
  print("main函数开始了");
  firstString();
  secondString();
  thirdString();
  print("main函数结束了");
}

firstString() async {
  print("firstString函数开始了");
  Future future = Future.delayed(Duration(milliseconds: 300), () {
    return "我是一个字符串";
  });
  print(await future);
  print("firstString函数结束了");
}

secondString() {
  print("我是二个字符串");
}

thirdString() {
  print("我是三个字符串");
}
输出结果：
main函数开始了
firstString函数开始了
我是二个字符串
我是三个字符串
main函数结束了
我是一个字符串
firstString函数结束了

main() async {
  print("main函数开始了：${DateTime.now()}");
  print(await firstString());
  print(await secondString());
  print(await thirdString());
  print("main函数结束了：${DateTime.now()}");
}

firstString() {
  return Future.delayed(Duration(milliseconds: 300), () {
    return "我是一个字符串";
  });
}

secondString() {
  return Future.delayed(Duration(milliseconds: 200), () {
    return "我是二个字符串";
  });
}

thirdString() {
  return Future.delayed(Duration(milliseconds: 100), () {
    return "我是三个字符串";
  });
}
输出结果：
main函数开始了：2020-10-13 16:24:46.897353
我是一个字符串
我是二个字符串
我是三个字符串
main函数结束了：2020-10-13 16:24:47.527151

异常下处理

void main() async {
  //注意：需要添加async，因为await必须在async方法内才有效
  try {
    var userInfo = await _loadUserFromSQL();
    var token = await _fetchSessionToken(userInfo);
    var data = await _fetchData(token);
    print('$data');
  } on Exception catch (e) {
    print('this is error: $e');
  } finally {
    print('all is done');
  }
  print('main is executed!');
}

通过对比发现使用 Future.then 相比 async-await 调用链路更清晰，基于异步回调的方式调用相比比较清晰。
而在代码实现以及同步结构分析 async-await 显得更加简单且处理异常也更加方面，更加符合同步代码的逻辑。

事件循环 - event loop

Flutter 中有两种队列

微任务队列（microtask queue）：主要是由 Dart 内部产生，表示一个短时间内就会完成的异步任务。(Future 的 then() 中的事件)【优先级最高】
事件队列（event queue)：包含所有的外部事件：I/O、mouse events、drawing events、timers、isolate之间的信息传递。(Future 的函数体)

微任务队列会优先执行，只要队列中有任务，就会一直占着事件循环。因此，如果有太多的微任务队列存在，可能会对事件队列中的触摸、绘制等外部事件造成一定的阻塞
Dart 会将 Future 异步任务的函数执行体放入 event queue，然后立即返回，后续 then() 的代码继续同步执行；当同步执行的代码执行完毕后，event queue 会按照加入event queue的顺序（即声明顺序），依次取出事件。

void main() {
  futureQueueTest();
}

void futureQueueTest() {
  Future future1 = Future(() => null);
  future1.then((value) {
    print('6');
    scheduleMicrotask(() => print(7));
  }).then((value) => print('8'));
  Future future2 = Future(() => print('1'));
  Future(() => print('2'));
  scheduleMicrotask(() => print('3'));
  future2.then((value) => print('4'));

  print('5');
}

运行结果

flutter: 5
flutter: 3
flutter: 6
flutter: 8
flutter: 7
flutter: 1
flutter: 4
flutter: 2

声明 Future 时，先将它们的异步函数执行体放入 event queue ，然后立即返回，后续代码继续同步执行。所以先打印5；
event loop循环先选择队列优先级高的微任务3执行，打印3；
event queue 按照加入 event queue的顺序（即声明顺序），依次取出事件，最后同步执行future1、future2的函数体及后续的操作。所以再打印6, 并将新声明的微任务7加入 event loop循环；
future1的函数体结束后，优先执行 future1 的后续操作then()。所以再打印8;
此时 future1 函数体及后续的操作全部执行完毕，再次 event loop循环选择队列优先级高的微任务7 执行，打印 7 ；
再次 event loop循环，执行 future2 的函数体及后续的操作，打印1和4；
再次 event loop循环，执行future的函数体及后续的操作，打印2；

参考资料：
https://juejin.cn/post/6976136324499636261#heading-15
https://www.jianshu.com/p/07047a534a01
https://juejin.cn/post/6939510009654935588

Flutter 的异步操作 Future、async、await 的用法