由于dart是一种单线程的语言，在编写dart代码时对于耗时操作的处理要使用异步来进行。dart中自带有future ，async/await，Isolate， stream和广播等异步操作等方式。

Dart中的事件循环

在dart中实际上有两种队列:

• 1.事件队列(event queue):包含所有的外来事件:I/O,mouse events, drawing events,timers,isolate之间的信息传递

• 2.微任务队列(microtask queue):表示一个短时间内就会完成的异步任务，它的优先级最高，高于event queue,只要队列中还有任务，就可以一直霸占着事件循环。microtask queue添加的任务只要是由Dart内部产生

dart 事件循环流程图

dart_loop_png.jpg

Future异步方式

常见处理耗时操作的返回值为future,不会阻塞当前的线程导致程序卡死。

void testFuture(){
print("FutureTest==开始")
  Future((){
    return "任务1";
  }).then((value) => print(value+"结束"));

  Future((){
    return "任务2";
  }).then((value) => print(value+"结束"));

  Future((){
    sleep(Duration(seconds: 1));
    return "任务3";
  }).then((value) => print(value+"结束"));

  Future((){
    return "任务4";
  }).then((value) => print(value+"结束"));

  Future((){
    return "任务5";
  }).then((value) => print(value+"结束"));
 print("FutureTest==结束")
}
//打印结果，输出不会阻塞当前线程
FutureTest==开始
FutureTest==结束
任务1结束
任务2结束
任务3结束
任务4结束
任务5结束

在future执行过程中，future执行的顺序和添加的顺序是一致的，上一个任务执行完成才会执行下一个future，在OC/Swift多线程中这些返回的顺序是不定的。

void testFuture1(){
  //future的执行顺序和添加顺序有关，在future中 then的比future的默认优先级要高，执行完了future直接执行then
  Future((){
    return "任务1";
  }).then((value) => print(value+"结束"));

  Future x = Future((){
    return "任务2";
  })

  Future((){
    return "任务3";
  }).then((value) => print(value+"结束"));

  Future((){
    return "任务4";
  }).then((value) => print(value+"结束"));

  Future((){
    return "任务5";
  }).then((value) => print(value+"结束"));
  
  x.then((value)=>print(value+"结束"));
}

//执行结果
任务1结束
任务2结束
任务3结束
任务4结束
任务5结束

future执行完成返回的是一个future对象，使用then()方法注册一个回调，Future->then->Complete认为是一个任务,这个任务处理完成了才能继续处理其他的任务，future执行任务中可以对error和complete事件做一个处理。

Future((){
    throw "发生错误了";
    return "你好";
  }).then((value) => print("我就是value"))
      .catchError((error)=>print("当前error==$error"))
      .whenComplete(() => print("当前事件结束了"));

对于Future来说，异步处理成功了就执行成功的操作，异步处理失败了就捕获错误或者停止后续操作。一个Future只会对应一个结果，要么成功，要么失败。Future.catchError回调只处理原始Future抛出的错误，不能处理回调函数抛出的错误，onError只能处理当前Future的错误,Future.whenComplete 在Future完成之后总是会调用，不管是错误导致的完成还是正常执行完毕。比如在网络请求前弹出加载对话框，在请求结束后关闭对话框。并且返回一个Future对象.

请记住，Future的所有API的返回值仍然是一个Future对象，所以可以很方便的进行链式调用。

微任务, 使用scheduleMicrotask()来创建一个微任务，优先级要比Future要高

//多种相互组合
void complexEventLoop(){
  print("开始执行");
  Future(()=>"1").then((value) => print("$value==结束"));
  var x = Future(()=>"2");
  var y = Future(()=> "6");
  y.then((value) => print("$value==结束"));
  x.then((value){
    print("$value==结束");
    scheduleMicrotask((){
      print("4==结束");
    });
  }).then((value) => print("3==结束"));
  scheduleMicrotask((){
    //微任务队列
    print("7==结束");
  });
  Future(()=> "5").then((value) => print("$value==结束"));
  print("结束执行");
}
//输出值
开始执行
结束执行
7==结束
1==结束
2==结束
3==结束
4==结束
6==结束
5==结束

结果分析

1.开始执行和结束执行是同步的，会按照顺序输出
2.任务7 是微任务优先级最高，第一个输出
3.接着按着Future加入的顺序开始执行 1 2
4.执行到2结束的时候then中有一个微任务，但是改Future任务还没有结束，会继续执行该任务输出3
5.任务3输出完成开始执行微任务 输出4
6.任务6对应的Future先执行，输出6
7.最后输出5

Future提供了几种方法实现

Future.value()，创建返回指定value的future

Future.value(1).then((value)=>print(value));
//输出值
1

Future.delayed() 创建一个延迟执行的future

Future.delayed(Duration(seconds: 1)).then((value) => print("延迟执行"));
//输出值
延迟执行

Future.then() 用来注册一个Future完成时要调用的回调。如果 Future 有多个then，它们也会按照链接的先后顺序同步执行，同时也会共用一个event loop。

Future((){
    return "任务5";
  }).then((value) => print(value+"结束"));

Future.timeout,超时会抛出TimeoutException异常处理

Future.delayed(new Duration(seconds: 2), () {
      return 1;
    }).timeout(new Duration(seconds:1)).then(print).catchError(print);

Future.foreach，根据某个集合创建一系列的Future，并且按着顺序执行这些Future，

Future.forEach({1,2,3}, (num){
      return Future.delayed(Duration(seconds: num),(){print("第$num秒执行");});
    });

Future.wait(),等待多个Future任务完成，

• 所有的future都有正常结果返回，使用then监听的方法获的是一个结果的集合，
• 其中一个或者多个Future发生错误，产生error，则Future返回的结果就是第一个发生错误的Future的值

void testFuture4() async {
  var future1 = new Future.delayed(new Duration(seconds: 1), () => 1);
  var future2 = new Future.delayed(new Duration(seconds: 2), () {
    return 5;
  });
  var future3 = new Future.delayed(new Duration(seconds: 3), () => 3);
  Future.wait([future1,future2,future3]).then((value) =>print(value))                                           
    .catchError((error)=>print(error));
 }
//输出值
[1, 5, 3]

void testFuture5() async {
  var future1 = new Future.delayed(new Duration(seconds: 1), () => 1);
  var future2 = new Future.delayed(new Duration(seconds: 2), () {
    throw 'Future 发生错误啦!';
  });
  var future3 = new Future.delayed(new Duration(seconds: 3), () => 3);
  Future.wait([future1,future2,future3]).then((value) =>print(value))                                           
    .catchError((error)=>print(error));
 }
//输出值
Future 发生错误啦!

Future.any,返回的是第一个执行完成的Future的结果，不管结果是正确还是错误

Future
    .any([1, 2, 5].map((delay) => new Future.delayed(new Duration(seconds: delay), () => delay)))
    .then(print)
    .catchError(print);
  }
///输出值
1

Future.doWhile ,重复执行某一个动作，直到返回false或者future，退出循环，适用一些递归的操作

var random = new Random();
var totalDelay = 0;
Future.doWhile(() {
  if (totalDelay > 10) {
    print('total delay: $totalDelay seconds');
    return false;
  }
  var delay = random.nextInt(5) + 1;
  totalDelay += delay;
  return new Future.delayed(new Duration(seconds: delay), () {
    print('waited $delay seconds');
    return true;
  });
}).then(print).catchError(print);

Future.sync 同步执行，然后调度到microtask queue来完成自己，也就是一个阻塞任务，会阻塞当前线程，sync执行完成了之后代码才会走到下一行

void testFuture() async {
    Future((){
        print("Future event 1");
    });
    Future.sync(() {
        print("Future sync event 2");
    });
    Future((){
        print("Future event 3");
    });
    Future.microtask((){
        print("microtask event");
    });
}
//输出值
Future sync event 2
microtask event
Future event 1
Future event 3

如果在sync中返回一个future,执行顺序也会发生改变。

void testFuture() async {
    Future((){
        print("Future event 1");
    });
    Future.sync(() {
        return Future(() => print("sync Future event 2"));
    });
    Future((){
        print("Future event 3");
    });
    Future.microtask((){
        print("microtask event");
    });
}
//输出值
microtask event
Future event 1
sync Future event 2
Future event 3

Future.microtask 创建一个在microtask queue运行的Future。

microtask queue的优先级要比event queue高，而一般Future是在event queue执行的，所以Future.microtask创建的Future会优先于其他的Future执行：

void testFuture() async {
    Future((){
        print("Future event 1");
    });
    Future((){
        print("Future event 2");
    });
    Future.microtask((){
        print("microtask event");
    });
}
///输出值
microtask event
Future event 1
Future event 2

async/await

默认future是异步执行的，如果想要future同步执行，可以通过async/await关键字:

void textAsyncAwait() async{
  String valuel = await Future((){
    return "这是就是value";
  });
  print("当前value===$valuel");
  print("函数执行完毕");
}
//输出值
当前value===这是就是value
函数执行完毕

可以看到Future已经开始同步执行了，await会等待Future执行结束后才会继续执行后面的代码，

关键字async/await 是dart异步支持的一部分，是一个语法糖，编译器或解释器最终都会将其转化为一个Promise(Future)的调用链

• async: 用来表示函数时异步的，定义的函数会返回一个Future对象
• await:后面跟着一个Future，表示等待该异步任务完成，异步任务完成后才会继续往下执行。await只能出现在异步函数内部，能够让我们可以像写同步代码一样来执行异步任务。

最后 Future的实现，

查看future的源码会发现，异步任务是基于timer实现的,定时器设置的时间间隔为zero，result返回值then进行回调注册拿到执行之后的结果 ，有兴趣的朋友可以更深层的探究一下

factory Future(FutureOr<T> computation()) {
    _Future<T> result = new _Future<T>();
    Timer.run(() {
      try {
        result._complete(computation());
      } catch (e, s) {
        _completeWithErrorCallback(result, e, s);
      }
    });
    return result;
  }

正在学习dart中，如有不足或错误的地方，欢迎指正。