42、Flutter之 Dart中的异步编程——Future、async和await

异步编程基本概念：

1、使命调度

先谈谈使命调度 ，大部分操作体系(如Windows、Linux)的使命调度是采用时刻片轮转的抢占式调度办法，对于单核CPU来讲，并行履行两个使命，实践上是CPU在进行着快速的切换，对用户来讲感觉不到有切换停顿，就好比220V交流电灯光显示原理一样，也便是说一个使命履行一小段时刻后强制暂停去履行下一个使命，每个使命轮番履行。

使命履行的一小段时刻叫做时刻片，使命正在履行时的状况叫运转状况，使命履行一段时刻后强制暂停去履行下一个使命，被暂停的使命就处于安排妥当状况等候下一个属于它的时刻片的到来，使命的停与履行切换，称之为使命调度。

2、进程

核算机的中心是CPU，它承当了所有的核算使命，而操作体系是核算机的办理者，它负责使命的调度、资源的分配和办理，操作体系中运转着多个进程，每一个进程是一个具有必定独立功能的程序在一个数据集上的一次动态履行的过程，是应用程序运转的载体。

操作体系会以进程为单位，分配体系资源（CPU时刻片、内存等资源），进程是资源分配的最小单位，也便是操作体系的最小单位。

3、线程

线程是进程中的概念，一个进程中可包括多个线程。

使命调度采用的是时刻片轮转的抢占式调度办法，进程是使命调度的最小单位。

默许情况下，一般一个进程里只要一个线程，进程自身便是线程，所以线程能够被称为轻量级进程。

4、协程

协程，是一种依据线程，但又比线程愈加轻量级的存在，是线程中的概念，一个线程能够拥有多个协程。

在传统的J2EE体系中都是依据每个请求占用一个线程去完结完好的业务逻辑（包括事务）。所以体系的吞吐能力取决于每个线程的操作耗时。假如遇到很耗时的I/O行为，则整个体系的吞吐立刻下降，由于这个时候线程一向处于堵塞状况，假如线程许多的时候，会存在许多其他的线程处于等候，空闲状况（等候前面的线程履行完才干履行），形成了资源应用不完全。

最常见的例子便是同步堵塞的JDBC，在衔接过程中线程根本没有运用CPU去做运算，而是处在等候状况，而另外过多的线程，也会带来更多的ContextSwitch(上下文切换)开支。

协程的呈现，当呈现长时刻的I/O操作时，经过让出当时占用的使命通道，履行下一个使命的办法，经过在线程中实现调度，来消除ContextSwitch上的开支，避免了陷入内核级其他上下文切换形成的性能损失，进而突破了线程在IO上的性能瓶颈。从编程角度上看，协程的思维本质上便是操控流的主动让出（yield）和恢复（resume）机制。

Flutter中的异步编程

Dart是依据单线程模型的言语，所以在Flutter中咱们一般的异步操作，实践上仍是经过单线程经过调度使命优先级来实现的。

在Dart中的线程机制，称为isolate，在Flutter项目中， 运转中的 Flutter 程序由一个或多个 isolate 组成，默许情况下发动的Flutter项目，经过main函数发动便是创立了一个main isolate，后续会有专门一文来论述isolate的开发运用，在这里咱们 main isolate 为Flutter的主线程，或者是UI线程。

单线程模型中主要便是在维护着一个事情循环（Event Loop） 与 两个行列（event queue和microtask queue）

当Flutter项目程序触发如点击事情、IO事情、网络事情时，它们就会被加入到eventLoop中，eventLoop一向在循环之中，当主线程发现事情行列不为空时发现，就会取出事情，而且履行。

microtask queue只处理在当时 isolate 中的使命，优先级高于event queue，好比机场里的某个VIP候机室，总是VIP用户先登机了，才敞开公共排队入口，假如在event事情行列中插入microtask，当当时event履行结束即可插队履行microtask事情，microtask queue行列的存在为Dart供给了给使命行列插队的解决方案。

当事情循环正在处理microtask事情时的时候，event queue会被堵塞。这时候app就无法进行UI绘制，响应鼠标事情和I/O等事情。

Dart中异步能够异步的来履行耗时操作。从而能够在等候一个操作完结的一起进行其他操作以下是一些常见的异步操作：

• 经过网络获取数据。
• 写入数据库。
• 从文件读取数据。

要在Dart中履行异步操作，能够运用Future类和async和await关键字。

关键字async和await是Dart言语异步支撑的一部分。

异步函数即在函数头中包括关键字async的函数。

• async：用来表明函数是异步的，定义的函数会回来一个Future目标。
• await：后边跟着一个Future，表明等候该异步使命完结，异步使命完结后才会持续往下履行。await只能呈现在异步函数内部。能够让咱们能够像写同步代码那样来履行异步使命而不运用回调的办法。

Dart的事情循环(event loop)

在Dart中，实践上有两种行列：

1. 事情行列(event queue)，包括所有的外来事情：I/O、mouse events、drawing events、timers、isolate之间的信息传递。
2. 微使命行列(microtask queue)，表明一个短时刻内就会完结的异步使命。它的优先级最高，高于event queue，只要行列中还有使命，就能够一向霸占着事情循环。microtask queue增加的使命主要是由Dart内部产生。

由于microtask queue的优先级高于event queue，所以假如microtask queue有太多的微使命， 那么就可能会霸占住当时的event loop。从而对event queue中的触摸、绘制等外部事情形成堵塞卡顿。

在每一次事情循环中，Dart总是先去第一个microtask queue中查询是否有可履行的使命，假如没有，才会处理后续的event queue的流程。

异步使命咱们用的最多的仍是优先级更低的event queue。Dart为event queue的使命树立供给了一层封装，便是咱们在Dart中经常用到的Future。

正常情况下，一个Future异步使命的履行是相对简单的：

1. 声明一个Future时，Dart会将异步使命的函数履行体放入event queue，然后当即回来，后续的代码持续同步履行。
2. 当同步履行的代码履行结束后，event queue会按照加入event queue的次序（即声明次序），顺次取出事情，最终同步履行Future的函数体及后续的操作。

Future

Future<T>类，其表明一个T类型的异步操作成果。假如异步操作不需求成果，则类型为Future<void>。也便是说首要Future是个泛型类，能够指定类型。假如没有指定相应类型的话，则Future会在履行动态的推导类型。

Future基本用法

Widget build(BuildContext context) {
  return Scaffold(
    appBar: getAppBar("async"),
    body: ElevatedButton(onPressed: (){
      test();
      print("履行其他使命");
    } , child: Text("测验异步")),
  );
}
void test()async{
  print("赋值使命开端");
  for(var i=0;i<100000000;i++ ){
    _data = i.toString();
  }
  print("赋值使命结束");
}

履行履行成果：

从成果能够看出履行是同步的，async仅仅告诉外部是一个异步办法，实践并没有加入到异步行列使命，假如要运用真正的异步，需求Future。

重新修正异步办法：

void test()async{
  print("赋值使命开端");
  await Future((){
    for(var i=0;i<10000000000;i++ ){
      _data = i.toString();
    }
  });
  print("赋值使命结束");
}

从运转成果能够看出加上 await Future今后遇到耗时使命时候切换先履行了其他使命，最终再切换履行完结耗时操作。

**Flutter供给了下面三个办法，让咱们来注册回调，来监听处理Future异步信息的成果： **

创立一个指定回来值的Future:

Future.value("sucess").then((value) => (debugPrint("测验$value")));

不需求等候成果的能够不运用await,await会堵塞代码向下履行，能够运用.then接受回调数据即可。如下图：

Future捕获反常

异步的反常捕获，Future.then除了onValue还有一个接受过错的办法，源码如下：

Future<R> then<R>(FutureOr<R> onValue(T value), {Function? onError});

catchError一般放在then和complete后边。否则调用反常后还会走到then呈现问题，Future比较完好的链式调用办法：

//Future。then的运用
Future future = Future((){
  //耗时操作
  for(var i=0;i<100000000;i++ ){
    _data = i.toString();
  }
  throw Exception("假如程序犯错");
  return "dddd";
});
//运用then来接收数据
future.then((value){
  print("好事使命履行结束：$value");
}).whenComplete((){
  debugPrint("完结了使命");
}).catchError((error){
  print(error.toString());
});

多个异步履行，Future使命会被增加到异步行列，然后顺次次序履行：

void testfutureMul(){
  Future((){
    return "task 1";
  }).then((value) => print('$value 结束'));
  Future((){
    return "task 2";
  }).then((value) => print('$value 结束'));
  Future((){
    return "task 3";
  }).then((value) => print('$value 结束'));
  Future((){
    return "task 4";
  }).then((value) => print('$value 结束'));
  print("使命增加结束");
}

上面例子能够看到首要主行列一次履行，增加使命1-4到异步行列，然后打印使命增加完结，异步中使命再持续履行，异步仅仅将使命增加到了另外的一个异步行列中，履行次序仍是顺次履行，不会无序的，只要完结一个使命才干履行下一个使命。

假如多个异步使命成果需求依赖，能够再履行when回调后return成果而且持续后.then履行下一个使命一次依赖。

Future.delayed

创立一个推迟履行的 Future:

//创立一个推迟履行的 Future:
//延时三秒履行
Future.delayed(Duration(seconds: 3),(){
  debugPrint("future delayed");
});
debugPrint("完结");

运转成果：

Future.forEach

依据某个调集，创立一系列的Future，而且会按次序履行这些Future：

//依据某个调集，创立一系列的Future，而且会按次序履行这些Future
Future.forEach([1,2,3,4], (element){
  return Future.delayed(Duration(seconds: 3),(){
    print(element);
  });
});
debugPrint("完结");

运转成果：

Future.wait

串行履行多个异步使命，多个异步履行完结后同时去处理的情况.then拿到的成果是一个成果数组： :

//串行履行多个使命
var f1 = Future.delayed(const Duration(seconds: 1),()=>(1));
var f2 = Future.delayed(const Duration(seconds: 2),()=>(2));
var f3 = Future.delayed(const Duration(seconds: 3),()=>(3));
var f4 = Future.delayed(const Duration(seconds: 4),()=>(4));
Future.wait([f1,f2,f3,f4]).then((value) => print(value)).catchError(print);
debugPrint("完结");

履行成果：

Future.sync

会同步履行其入参函数，然后调度到microtask queue来完结自己。也便是一个堵塞使命，会堵塞当时代码，sync的使命履行完了，代码才干走到下一行：

void testFuture() async {
    Future((){
        print("Future event 1");
    });
    Future.sync(() {
        print("Future sync microtask event 2");
    });
    Future((){
        print("Future event 3");
    });
    Future.microtask((){
        print("microtask event");
    });
}
testFuture();
print("在testFuture()履行之后打印。");

履行成果：

Future sync microtask event 2
在testFuture()履行之后打印。
microtask event
Future event 1
Future event 3

在上述创立的异步使命都是增加到event行列中的使命，创立一个在microtask行列运转的future，microtask行列的优先级是比event行列高的。

Future工厂结构函数

工厂结构函数是一种结构函数，与普通结构函数不同，工厂函数不会自动生成实例，而是经过代码来决定回来的实例目标。
在Dart中，工厂结构函数的关键字为factory。咱们知道，结构函数包括类名结构函数和命名结构办法，在结构办法前加上factory之后变成了工厂结构函数。也便是说factory能够放在类名函数之前，也能够放在命名函数之前。

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;
}

本文正在参加「金石计划 . 分割6万现金大奖」