flutter async和await原理解析(await阻塞当前方法，不阻塞方法外的代码继续执行）

一 . async await 与 Future

在异步调用中有三个关键词，async、await、Future，其中async和await需要一起使用。在Dart中可以通过async和await进行异步操作，async表示开启一个异步操作，也可以返回一个Future结果。如果没有返回值，则默认返回一个返回值为null的Future。

await的操作，不会影响方法外后续代码的执行;只会阻塞async方法的后续代码

例子1

_testAsyncKeyword() {
    print("test函数开始了：${DateTime.now()}");
    _testString().then((value) => print(value));
    print("test函数结束了：${DateTime.now()}");
  }

  Future<String> _testString() async {
    Future f = Future.delayed(Duration(milliseconds: 300), () {
      return "我是测试字符串===1";
    });
    String result = await f;
    print("我是测试字符串===2");
    return result;
  }
// flutter: test函数开始了：2021-05-27 13:58:56.595964
// flutter: test函数结束了：2021-05-27 13:58:56.598801
// flutter: 我是测试字符串===2
// flutter: 我是测试字符串===1

在代码示例中,执行到_testString()方法,会同步进入方法内部进行执行，当执行到await时就会停止async内部的执行，从而继续执行外面的代码。所以await的操作，不会影响后面代码的执行("test函数结束了"会先于_testString()内部打印)。
当await有返回后，会继续从await的位置继续执行(所以先打印出了 "我是测试字符串===2" ,然后返回Future的结果,并通过print打印出 "我是测试字符串===1")。

例子2

_testAsyncKeyword() async {
    print("test函数开始了：${DateTime.now()}");
    print(await _testString());
    print("test函数结束了：${DateTime.now()}");
  }

  Future<String> _testString() async {
    Future f = Future.delayed(Duration(milliseconds: 300), () {
      return "我是测试字符串===1";
    });
    String result = await f;
    print("我是测试字符串===2");
    return result;
  }

// flutter: test函数开始了：2021-05-27 14:06:48.185704
// flutter: 我是测试字符串===2
// flutter: 我是测试字符串===1
// flutter: test函数结束了：2021-05-27 14:06:48.497481

在代码示例中, _testAsyncKeyword() 本身内部就有一个await操作,当执行到await时就会停止_testAsyncKeyword() async内部的执行.等待_testString()有结果返回之后,继续执行.

_testString()内部也是有一个await操作,当执行到await时就会停止_testString() async内部的执行,等待300毫秒,Future有结果后,打印字符串2

_testAsyncKeyword() 继续执行 打印 字符串1 及 结束

例子3

_testAsyncKeyword() {
    print("test函数开始了：${DateTime.now()}");
    firstString().then((value) => print(value));
    secondString().then((value) => print(value));
    thirdString().then((value) => print(value));
    print("test函数结束了：${DateTime.now()}");
  }

_testKeyword2() async{
    print("test函数开始了：${DateTime.now()}");
    print(await firstString());
    print(await secondString());
    print(await thirdString());
    print("test函数结束了：${DateTime.now()}");
  }
Future<String> firstString() {
    return Future.delayed(Duration(milliseconds: 300), () {
      return "我是一个字符串";
    });
  }

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

  Future<String> thirdString() {
    return Future.delayed(Duration(milliseconds: 100), () {
      return "我是三个字符串";
    });
  }

//_testAsyncKeyword() 的打印:
//flutter: test函数开始了：2021-05-27 14:17:42.620409
//flutter: test函数结束了：2021-05-27 14:17:42.624359
//flutter: 我是三个字符串
//flutter: 我是二个字符串
//flutter: 我是一个字符串

//_testKeyword2() 的打印:
//flutter: test函数开始了：2021-05-27 14:18:41.401992
//flutter: 我是一个字符串
//flutter: 我是二个字符串
//flutter: 我是三个字符串
//flutter: test函数结束了：2021-05-27 14:18:42.027575

通过上面三个例子 , 大家应该可以看出 await async 和 then之间的区别和联系了吧.

二. async、await的原理

async、await的操作属于"假异步",这是为什么呢?
如果想要得到这个问题的答案,首先我们需要了解async、await的原理，了解协程的概念，因为async、await本质上就是协程的一种语法糖。协程，也叫作coroutine，是一种比线程更小的单元。如果从单元大小来说，基本可以理解为 进程->线程->协程。

1.任务调度

在弄懂协程之前，首先要明白并发和并行的概念

• 并发: 指的是由系统来管理多个IO的切换，并交由CPU去处理。
• 并行: 指的是多核CPU在同一时间里执行多个任务。

并发的实现由非阻塞操作+事件通知来完成，事件通知也叫做“中断”。操作过程分为两种，一种是CPU对IO进行操作，在操作完成后发起中断告诉IO操作完成。另一种是IO发起中断，告诉CPU可以进行操作。

线程: 本质上也是依赖于中断来进行调度的，线程还有一种叫做“阻塞式中断”，就是在执行IO操作时将线程阻塞，等待执行完成后再继续执行,通过单线程并发可以进行大量并发操作。但线程的消耗是很大的，并不适合大量并发操作的处理,且单个线程只能使用到单个CPU。当多核CPU出现后，单个线程就无法很好的利用多核CPU的优势了，所以又引入了线程池的概念，通过线程池来管理大量线程。当需要同时执行多项任务的时候，我们就会采用多线程并发执行.

单线程并发 7.单线程并发 - 简书

Dart单线程运行模型: 输入单吸纳成运行机制,主要是通过消息循环机制来实现任务调度和处理的.

2.协程coroutine

关于协程 https://zhuanlan.zhihu.com/p/172471249
多线程并发 操作系统在线程等待IO的时候，会阻塞当前线程，切换到其它线程，这样在当前线程等待IO的过程中，其它线程可以继续执行。当系统线程较少的时候没有什么问题，但是当线程数量非常多的时候，却产生了问题。一是系统线程会占用非常多的内存空间，二是过多的线程切换会占用大量的系统时间。
协程 运行在线程之上，当一个协程执行完成后，可以选择主动让出，让另一个协程运行在当前线程之上。协程并没有增加线程数量，只是在线程的基础之上通过分时复用的方式运行多个协程，而且协程的切换在用户态完成，切换的代价比线程从用户态到内核态的代价小很多。

协程分为无线协程和有线协程.

• 无线协程在离开当前调用位置时，会将当前变量放在 堆区，当再次回到当前位置时，还会继续从堆区中获取到变量。所以，一般在执行当前函数时就会将变量直接分配到堆区，而async、await就属于无线协程的一种。
• 有线协程则会将变量继续保存在 栈区，在回到指针指向的离开位置时，会继续从栈中取出调用。

3.async、await原理

之所以说async/await是假异步,是因为他在执行过程中并没有开启新的线程更没有并发执行,而是通过单线程上的任务调度(协程,没有并发执行功能)实现的:
当代码执行到async则表示进入一个协程，会同步执行async的代码块。async的代码块本质上也相当于一个函数，并且有自己的上下文环境。当执行到await时，则表示有任务需要等待，CPU则去调度执行其他IO，也就是后面的代码或其他协程代码。过一段时间CPU就会轮询一次，看某个协程是否任务已经处理完成，有返回结果可以被继续执行，如果可以被继续执行的话，则会沿着上次离开时指针指向的位置继续执行，也就是await标志的位置。

由于并没有开启新的线程，只是进行IO中断改变CPU调度，所以网络请求这样的异步操作可以使用async、await，但如果是执行大量耗时同步操作的话，应该使用isolate开辟新的线程去执行。

---

源码解析

wait(Iterable futures，{bool eagerError = false, void cleanUp(T successValue)?})

• Iterable futures 这个参数应该大多数人都知道，而且大多数都只用这一个参数。就是一个Future的数组，你把所有的Future函数都放这个数组里。
• eagerError 这个参数很少人用，它用于是否需要立即返回error。eagerError为ture时，这个error是futures中任何一个接口发生错误了，就立即获得error。但是不会中断其它futures中未执行完的函数继续执行；当eagerError为false时，会等所有的futures都执行完之后，才会把futures中发生的第一个error发出来。
• void cleanUp(T successValue)?这是一个Fuction，从命名上看，是清除的意思，不看源码其实很难理解清除什么。这个在实际使用的时候，只有在futures中至少有一个future发生了error才会执行这个方法。这个方法中可以获取到所有执行成功那部分future的value。

值得注意的是： Future.wait（）这个操作符中所有futures，当它们发生错误时，只会返回第一个error，也就是超过2个接口报错了，你只能拿到第一个接口的错误。

下面看下源码

static Future<List<T>> wait<T>(Iterable<Future<T>> futures,
      {bool eagerError = false, void cleanUp(T successValue)?}) {
    final _Future<List<T>> _future = _Future<List<T>>();
    List<T?>? values; // 一个用于存放value的集合，如果是error,则存null
    int remaining = 0; // 可以理解为futures顺序执行的队列大小。
    late Object error; // 用于存放futures中第一个发生的错误
    late StackTrace stackTrace; // 用于存放这个是和error对应的错误的方法调用栈
    //这是个内部方法，用于处理错误
    void handleError(Object theError, StackTrace theStackTrace) {
      remaining--;
  	  xxx....
  	  //这里省略部分代码
  	  xxx.....
    }

    try {
      for (var future in futures) {//遍历需要调用的方法，给每个future添加then回调。
        int pos = remaining;//把对应的下标记录下来，再下面的then中需要使用
        future.then((T value) {
          remaining--;
          xxx....
  	  	 //这里省略部分代码
  	  	  xxx.....
        }, onError: handleError);
        remaining++;//队列总数+1
      }
      if (remaining == 0) { //futures列表为空或者，直接结束
        return _future.._completeWithValue(<T>[]);
      }
      values = new List<T?>.filled(remaining, null);//初始化一个大小为remaining的数组容器。用于存放所有futures的value
    } catch (e, st) {
     xxx....
     //省略部分代码
     xxx....
    }
    return _future;
  }

从代码大体框架可以看出，首先第一步是按照数组futures中的顺序给每个future添加一个then操作符，并且创建一个values用来存放所有futures中的value。并且声明了两个局部变量error和stackTrace，用于存放futures发生的第一个错误的error以及方法调用栈。

如果futures数组为空，则直接结束这个Future。

内部函数handleError方法的逻辑

 	 void handleError(Object theError, StackTrace theStackTrace) {
      remaining--;
      List<T?>? valueList = values;
      if (valueList != null) {
        if (cleanUp != null) {
          for (var value in valueList) {
            if (value != null) {
              // Ensure errors from cleanUp are uncaught.
              T cleanUpValue = value;
              new Future.sync(() {
                cleanUp(cleanUpValue);
              });
            }
          }
        }
        values = null;
        if (remaining == 0 || eagerError) {
          _future._completeError(theError, theStackTrace);
        } else {
          error = theError;
          stackTrace = theStackTrace;
        }
      } else if (remaining == 0 && !eagerError) {
       //省略部分代码
      }
    }

这部分代码逻辑也很简单清晰。

1. 将所有的values值通过cleanUp的回调发送出去，当所有的values都发送完毕之后，values赋null值；

2. 第二个if以下有3种情况
a. 如果所有的futures都执行完了，将error抛出去，
b. eagarError为true时，将发生的error直接输出，
c. 以上两个条件都满足了，那肯定也error直接抛出去了。

3. 如果不需要futures没有执行完，且不需要立即把error抛出，则将error缓存下来。看到这个地方时，肯定有一个疑问。如果futures中发生第二个错误的时候，也满足eagerError为false并且futures还没执行完时，第二个error信息岂不是会覆盖之前的缓存，这个和之前定义的error只会输出第一个有点相违背呀。

继续往下看。

void handleError(Object theError, StackTrace theStackTrace) {
      remaining--;
      List<T?>? valueList = values;
      if (valueList != null) {
       //省略部分代码
      } else if (remaining == 0 && !eagerError) {
        _future._completeError(error, stackTrace);
      }
    }

这里把前面if内的代码屏蔽，这样看着更清晰一点。逻辑很简单，在某种条件下将error信息抛出。具体条件如下：
首先 因为第一个错误发生的时候，在if内部已经将values赋值为null了，所以第二个错误发生的时候，就会走这个else的逻辑了。
其次，这个else中又添加了2个条件。所有的futures没有执行完并且eagerError这个参数为false（也就是不需要立即抛出error）。这不就是恰巧回答了上面那个疑问么。
因此， 当第二个及以后error发生的时候，都被这个handler自己吃掉了，不会再往外抛。

then函数中if逻辑

future.then((T value) {
          remaining--;
          List<T?>? valueList = values;
          if (valueList != null) {
            valueList[pos] = value;
            if (remaining == 0) {
              _future._completeWithValue(List<T>.from(valueList));
            }
          } else {
           //省略部分代码
          }
        }, onError: handleError);

这部分逻辑也很清晰，pos在前面描述过，记录了futures的对应位置。就是按照futures的顺序将所有的value添加到values中，没添加完一个就remaining减一，直到remaining为0，则表示所有的future中的value都添加完了，最后把这个values列表通过_completeWithValue下发一个数组。

换个角度说Future.wait().then(value =>{})中获取到的这个value会是个数组，数组里面所有元素的顺序和futures中每个方法的顺序是一样的。
 

then中else的逻辑

future.then((T value) {
          remaining--;
          List<T?>? valueList = values;
          if (valueList != null) {
           //省略部分代码
          } else {
            if (cleanUp != null && value != null) {
              new Future.sync(() {
                cleanUp(value);
              });
            }
            if (remaining == 0 && !eagerError) {
              _future._completeError(error, stackTrace);
            }
          }
        }, onError: handleError);

当这个values为null时，将当前的value通过cleanUp直接输出。也就是在前面提到的，cleanUp回调函数中可以获取到对应future的value。
前面在handlerError中有提到，当future中发生error的时候，如果eagerError为true，则values就会被赋值为null，所以当发生error之后所有的value就不会被缓存了，会直接通过cleanUp的方式往外输出。

如果eagerError为false时，
 

 if (remaining == 0 && !eagerError) {
     _future._completeError(error, stackTrace);
 }

这段代码就会执行，输出之前缓存的error。

总结

1. 参数Iterable futures中所有的future是按顺序执行的
2. 当其中一个或者多个future发生错误时，会根据eagerError参数判断是会否缓存第一个error和它的堆栈信息
   • a.eagerError 为ture，发生错误之后就会把之前所有的已经执行完的future的value，通过cleanUp清除，并且在这个回调函数中可以获取到
   • b. eagerError 为false，则会把第一个错误的error及相关信息缓存下来。直到所有future执行完了之后，通过clean Up回调输出所有的value，最后输出error及相关信息。
3. 至于所有的future都成功执行之后，才会走then回调。