Dart事件循环：为何Case 4输出顺序为A C G W Z B D E F？

案例1：基础示例 #

Future<void> main() async {
 print('A');

  await Future(
    () {
      print('C');
      Future(() => print('D'));
      Future(() => print('E')).then((value) => print('F'));
      Future.microtask(() => print('W'));
      Future.microtask(() => print('Z'));
      print('G');
    },
  );

  print('B');
}

输出结果：A C G B W Z D E F

• 首先输出A，同步代码优先级最高，按顺序执行。
• 遇到await Future，立即执行Future构造函数内的同步代码块，main函数后续的print('B')暂停，等待该Future完成。
• Future内部先执行同步逻辑：输出C，随后创建普通Future（进入事件队列）和微任务（进入微任务队列），最后输出G，这些异步任务不会立即执行。
• Future内部同步代码执行完毕后，该Future标记完成，main函数恢复执行，输出B。
• main函数执行结束后，事件循环启动：优先清空微任务队列，依次输出W、Z；再处理事件队列的普通Future，输出D、E，E的then回调执行输出F。

案例2 #

Future<void> main() async {
 print('A');

  await Future(
    () async {
      print('C');
      Future(() => print('D'));
      await Future(() => print('E')).then((value) => print('F'));
      Future.microtask(() => print('W'));
      Future.microtask(() => print('Z'));
      print('G');
    },
  );

  print('B');
}

输出结果：A C D E F G B W Z

• Future内部是async函数，遇到await Future(() => print('E'))时，暂停当前async函数执行，等待该Future完成。
• 事件循环先处理已在队列中的任务：事件队列里的Future(() => print('D'))先执行，输出D；接着处理await对应的Future，输出E，其then回调执行输出F。
• await的Future完成后，恢复执行async函数后续代码：创建两个微任务，输出G。
• 外层Future完成，main函数恢复执行输出B，最后事件循环处理微任务队列，输出W、Z。

案例3 #

Future<void> main() async {
 print('A');

  await Future(
    () async {
      print('C');
      Future(() => print('D'));
      Future(() => print('E')).then((value) => print('F'));
      Future.microtask(() => print('W'));
      await Future.microtask(() => print('Z'));
      print('G');
    },
  );

  print('B');
}

输出结果：A C W Z G B D E F

• Future内部的async函数遇到await Future.microtask(() => print('Z'))时，暂停执行，等待该微任务完成。
• 事件循环优先处理微任务队列：先执行之前加入的Future.microtask(() => print('W'))，输出W；再执行await对应的微任务，输出Z。
• 微任务队列清空后，恢复执行async函数后续代码，输出G。
• 外层Future完成，main函数恢复输出B；最后事件循环处理事件队列的普通Future，输出D、E、F。

案例4：疑问解析 #

Future<void> main() async {
 print('A');

  await Future(
    () async {
      print('C');
      Future(() => print('D'));
      Future(() => print('E')).then((value) => print('F'));
      Future.microtask(() => print('W'));
      Future.microtask(() => print('Z'));
      print('G');
    },
  );

  print('B');
}

输出结果：A C G W Z B D E F

• 核心差异在于：外层await的是由async函数创建的Future。当async函数内部同步代码执行完毕（输出C、创建异步任务、输出G）后，async函数不会立即标记返回的Future为完成，而是会将Future的完成事件加入微任务队列。
• 流程细节：
  1. 同步输出A，进入await Future，执行内部async函数的同步逻辑：输出C、创建异步任务、输出G。
  2. async函数执行到末尾，将返回Future的完成事件加入微任务队列，此时外层await仍处于等待状态。
  3. 事件循环处理微任务队列：依次执行W、Z。
  4. 微任务队列清空后，async函数返回的Future被标记为完成，外层await恢复执行，main函数输出B。
  5. 最后事件循环处理事件队列的普通Future，输出D、E、F。

内容的提问来源于stack exchange，提问作者alex.dart