Flutter中的异步

Dart是flutter开发语言。我们经常听说Dart是一门单线程的语言，这里说的单线程并不是说dart没有或不能使用多线程，而是dart的所有API默认情况下都是单线程的，在使用dart开发时我们几乎不用担心多线程的问题。但是Dart通过对异步操作的支持，使我可以在等待一个操作完成的同时进行别的操作，实现多任务同时进行。

基础概念：event loop、event queue 、microtask queue

跟iOS的Runloop很像，Dart的线程（Isolate）里面也有事件循环(event loop)，event loop的职责就是不断从事件队列中取出事件并处理他们直到事件队列为空。dart中有两个队列：

事件队列(event queue)，包含所有的外来事件：I/O、mouse events、drawing events、timers、isolate之间的信息传递。

微任务队列(microtask queue)，表示一个短时间内就会完成的异步任务。它的优先级最高，高于event queue，只要队列中还有任务，就可以一直霸占着事件循环。microtask queue添加的任务主要是由 Dart内部产生，当然我们也可以自己添加任务到microtask queue中去，但是我们不要在microtask queue里面实现耗时操作避免阻塞event queue里的UI事件导致卡顿现象。

因为microtask queue 的优先级要比event queue的高，所以event loop 每次循环总是先判断microtask queue中是否有任务需要执行，如果有则先执行microtask queue里的任务，执行完毕之后才会执行event queue。如下图所示：

4b40c19cd671683b567eaf567c7ca3da.jpg

异步任务我们用的最多的还是优先级更低的 event queue。Dart为 event queue 的任务建立提供了一层封装，就是我们在Dart中经常用到的Future，通常情况下，Future创建的任务他都会丢到event queue里面，然后这些任务会在event loop循环过程中执行。

常用关键词：Future、await 、async

Future、await 、async是dart里面经常使用的实现异步操作的关键字。通过Future可以避免阻塞当前代码。

Future通过泛型指定类型的异步操作结果（不需要结果可以使用Future）当一个返回 future 对象的函数被调用时，函数将被放入队列等待执行并返回一个未完成的Future对象，等函数操作执行完成时，Future对象变为完成并携带一个值或一个错误。

Future的用法很简单，如下所示：

void testFutures1() {
  print('1');
  Future((){
    print('2');
 });
 print('3');
}

打印结果：

1
3
2

从调用顺序可以看出，这里的Future实现了异步操作，代码先打印1再把Future任务添加到event queue里面，然后立即返回同步打印3，最后才打印2。前面我们提到过Future声明的任务会添加到event queue里面，所以可以推出多个Future任务顺序创建它也应该是按循序执行的，可以通过如下代码验证：

 void testFutures1(){
   Future((){
     print('1');
   });
   Future((){
     print('2');
   });
   Future((){
     print('3');
   });
   Future((){
     print('4');
   });
 }

打印结果：

这里跟我们在iOS开发中GCD的异步队列可能不一样，不一样的地方在于Future实现的异步他并不会创建新的线程，而仅仅是不阻碍当前前程而已。因此它的执行顺序跟它的添加顺序是一样的。
Future可以实现异步调用，但是有时候我们希望Future里面的任务能够同步执行，这时候await就可以派上用场了，具体操作如下：

void testFutures1() async{
   print('1');
   await Future((){
     print('2');
   });
   print('3');
}

打印结果：

1
2
3

通过调用循序我们可以发现，在Futrue前面加上await关键字就可以轻松实现同步操作，加上await之后，Future后面的代码都会同步执行。其中我们注意到，在方法testFutures1后面加上async关键字，这里要说的是，在方法中使用这个await关键字就必须要在方法后面加上async，async表示开启一个异步操作，async、await本质上就是Dart对异步操作的一个语法糖，可以减少异步调用的嵌套调用。async修饰的方法如果有返回值，则默认情况会返回一个Future。Future是一个抽象类行，通过泛型指定方法返回的数据类型。如果不指定类型，Future也能根据当前返回结果自动推出数据类型。代码示例：

void testFutures1() async{
  var result = await testFutures11();
    print(result);
}
Future testFutures11() async{
   return 1;
}

Future的一些常用方法

then、catchError

在前面我们提到可以通过await同步获取Future执行的结果，但是如果我们想异步获取Future执行的结果呢？那我们就可以通过then方法来获取Future执行的回调。具体示例如下：

void testFutures1() async{
   Future((){
     // throw Exception('这是一个异常');
    return 3;
   }).then((value){
     print(value);
   });
}

而且在Future执行的过程中可能会发生错误并抛出异常，这时候我们可以通过catchError来捕获异常，代码示例：

void testFutures1() async{
   Future((){
     // throw Exception('这是一个异常');
    return 3;
   }).then((value){
     print(value);
   }).catchError((error){
     print(error);
   });
}

以上代码如果执行Future的任务出现异常则不会走then方法而是直接调用catchError方法，而如果不实现catchError则会抛出异常信息。所以这里在使用then的时候最好配套使用catchError捕获可能出现的异常。

Future 链式调用

以上这段代码中，Future中的任务执行完之后会执行then方法，实际上then、catchError方法返回的也是一个Future，这样就使得我们可以进行链式调用，使代码实现更加灵活。我们可以通过下面的代码更直观地了解：

void testFutures1() async{
   Future((){
     print(1);
     return 1 + 1;
   }).then((value){
     print(value);
     return value + 1;
   }).then((value){
     print(value);
     throw Exception('这是一个异常');
   }).then((value){
     return value;
   }).catchError((error){
     print(error);
   });
 }

打印结果:

1 
2
3
Exception: 这是一个异常

这其中then方法返回的Future可以继续调用then，当我们有需要依赖的任务就可以使用这种方式处理。这里注意的是，上面代码中，不管哪个then方法抛出异常，后面的then都不会执行，而是直接会调用catchError。

前面我们讲过Dart 的 Isolate有两个队列，event queue 和 microtask queue，而Future的任务正常都会丢到event queue里面顺序执行。而then返回的也是一个Future，那then里面任务是不是也放在event queue里面呢？这个问题待后面介绍完microtask queue之后再进行分析。

Future.wait

我们可以通过await来实现Future的同步，但是如果我们希望同时等待多个Future执行完成之后再执行下一步任务该怎么实现呢？这时候Future.wait就非常有用了，让我们看一下代码示例吧：

void testFutures1() async{
   Future future1 = Future((){
     print(1);
     return 1;
   });
   Future future2 = Future((){
     print(2);
     return 2;
   });
   Future.wait([future1, future2]).then((value){
     print(value);
   }).catchError((error){});
 }

打印结果：

1
2
[1, 2]

可见方法Future.wait实现多个Future的同步执行，并且它的then方法的返回结果是一个数组，元素对应的Future数组里的返回结果。

Future还有很多有意思的方法，比如 Future.doWhile() 、Future.any()、Future.delay()等等，有空再慢慢学习。

微任务队列(microtask queue)

有前面的知识我们可以知道microtask queue 的优先级比event queue还高，那我们如何去证明呢？可以参考如下代码示例：

void testFutures4() async{
  Future((){// Future创建的任务会添加到事件队列里面
    print('1');
  });
  Future((){
    print('2');
  });
  scheduleMicrotask((){//创建一个微队列任务
    print('3'); //优先级比事件队列高，Future在事件队列里面
  });
  Future((){
    print('4');
  });
}

打印结果：

上面代码中scheduleMicrotask创建的任务会被丢到microtask queue中，而Future创建的任务则会丢到经过反复执行，打印循序一直都是3、1、2、4，可见microtask queue任务优先级是要比event queue优先级高。

这里需要说明的是microtask queue因为优先级比event queue高，event queue里面包括我们的UI和外部输入等事件，所以我们应该避免使用microtask queue，以防阻塞event queue导致UI卡顿等问题。而且microtask queue顾名思义，就是处理轻量级任务的。

关于Future的then的执行时机。

关于Future的then的执行时机，我们可以通过下面的代码分析：

void testFutures4() async{
  Future future1 = Future((){
    print('1');
  });
  Future future2 = Future((){
    print('2');
  });
  future2.then((value) => print('3'));
  scheduleMicrotask((){
    print('4'); //优先级比事件队列高，Future在事件队列里面
  });
  Future((){
    print('5');
  }).then((value) => print('6'));
  //微任务
  scheduleMicrotask((){
    print('7'); //优先级比事件队列高，Future在事件队列里面
  });
  print('8');
  future1.then((value) => print('9'));
}

打印结果：

1、8=>7可以看出microtask event 也是异步执行的；
2、7=>4可以看出microtask event也是安添加顺序执行；
3、8=>7=>4=>1 可以看出 microtask event 优先级比event queue优先级高，这个我们前面已经证实过了；
4、1=>9=>2=>3=>5=>6 可以看出Future的then总是在Future后面执行的。尽管future1和then之间插入了future2任务，但是future1的then依然在依然紧随future1执行的。由此可以得出，Future的then并不是单纯的添加的event queue队列中，而是通过可能通过其他的方式使得Future任务完成之后立即同步执行then方法。

Flutter中的异步

基础概念：event loop、event queue 、microtask queue

常用关键词：Future、await 、async

Future的一些常用方法

then、catchError

Future 链式调用

Future.wait

微任务队列(microtask queue)

关于Future的then的执行时机。

你可能感兴趣的:(Flutter中的异步)