Dart入门07 -- 异步

作者: YanZi_33 | 来源:发表于2021-11-08 09:40 被阅读0次

在Dart中处理耗时操作(网络请求，文件读取)，采用的的处理方式为单线程 + 事件循环，而在OC，Java中采用的是多线程；

阻塞式调用与非阻塞式调用

其是操作系统中的概念；
其关注的是程序在等待调用结果时的状态；
阻塞式调用：在调用结果返回之前，当前线程会被挂起，调用线程只有在得到调用结果之前才能继续执行；
非阻塞式调用：调用执行之后，当前线程不会停止执行，只需要过一段时间来检查一下有没有结果返回即可；

Dart事件循环

事件循环：其将需要处理的一系列事件(包括点击事件，IO事件，网络事件)放在一个事件队列中，然后不断的从事件队列中取出事件，并执行其对应需要执行的代码块，直到事件队列清空位置；

Dart的异步操作

Dart的异步操作有三种，分别为：Future，async和await；

Future

Future就是一个受你委托的委托人，你将未来要执行的任务交给他，你告知他任务类型是耗时任务，还是非耗时任务，然后分类放到事件循环中去，当任务完成后，它会第一时间执行回调方法告知你任务完成，或者会等到你委托给他的所有任务都完成了立马告知你；
Future可以看成是包装task任务的；
Future的创建方式有如下几种方式：
- new Future(task函数) 异步 task任务会延迟执行；
- new Future.sync(task函数) 同步 task任务会立即执行；
- new Future.delayed(延迟时间,task任务) 延迟执行task任务；
案例代码如下：

void main(List<String> args) {
  print("main 函数开始执行");
  //根据任务创建Future
  Future future1 = new Future(Task);

  Future future = new Future.sync(() {
    print("同步任务执行");
  });

  Future future2 = new Future(() {
    print("task2 执行");
  });

  print("main函数结束执行");
}

void Task() {
  print("task1 执行");
}

控制台执行结果如下：

image.png

void main(List<String> args) {
  print("main函数开始执行");
  Future future = new Future.delayed(Duration(seconds: 2), () {
    print("任务延迟2秒后 开始执行");
  });
  print("main函数结束执行");
}

控制台打印结果：

image.png

Future注册回调，当耗时任务执行完成后，会执行回调函数，注册回调有如下几种方式：
- then回调：当Future中的任务完成后，我们往往需要一个回调，这个回调立即执行，不会被添加到事件队列，then回调可支持多个回调；
- catchError回调：可用来处理异常；
- 静态方法wait：等待多个任务全部完成后回调；
then回调，案例代码如下：

void main(List<String> args) {
  print("main函数开始执行");
  Future future = new Future(() {
    print("task 执行");
  });

  future.then((value) {
    print("task 执行完成的回调");
  });
  print("main函数结束执行");
}

控制台打印结果：

image.png

then支持多个回调，案例代码如下：

void main(List<String> args) {
  print("main函数开始执行");
  Future future = new Future(() {
    print("task 执行");
  });

  future.then((value) {
    print("task 执行完成的回调");
  }).then((value) {
    print("task 回调完成之后");
  });
  print("main函数结束执行");
}

控制台打印结果如下：

image.png

catchError回调，案例代码如下：

void main(List<String> args) {
  print("main函数开始执行");
  new Future(() {
    print("task 任务");
  }).then((value) {
    print("task 任务执行完成的回调");
  }).then((value) {
    print("task 回调完成之后的处理");
  }).catchError((e) {
    print("task 任务执行出现异常的回调");
  });
  print("main函数结束执行");
}

静态方法wait，多个异步耗时操作同时执行，结果统一处理，案例代码如下：

void main(List<String> args) {
  print("main函数开始执行");
  Future future1 = new Future(() {
    print("task1");
    return 1;
  });

  Future future2 = new Future(() {
    print("task2");
    return 2;
  });

  Future future3 = new Future(() {
    print("task3");
    return 3;
  });

  Future future = Future.wait([future1, future2, future3]);
  future.then((value) {
    print(value);
  });

  print("main函数结束执行");
}

控制台打印结果如下：

image.png

wait函数返回一个新的Future，当添加的所有Future完成时，会在新的Future注册的回调将被执行；

await 与 async

在Dart1.9中加入了async和await关键字，有了这两个关键字，我们可以更简洁的编写异步代码，而不需要调用Future相关的API；
将 async 关键字作为方法声明的后缀时，具有如下意义：
- 被修饰的方法会将一个 Future 对象作为返回值；
- 该方法会 同步执行 其中的方法的代码直到第一个 await 关键字，然后它暂停该方法其他部分的执行；
- 一旦由 await 关键字引用的 Future 任务执行完成，await的下一行代码将立即执行；
实现请求的依赖，顺序执行，案例代码如下：

import 'dart:io';

main(List<String> args) {
  print("main start");

  getData();

  print("main end");
}

void getData() async {
  //链式调用
  var res1 = await getNetworkData("SF");
  print(res1);
  var res2 = await getNetworkData(res1);
  print(res2);
  var res3 = await getNetworkData(res2);
  print(res3);
}

//异步函数
//1.await必须在async函数中才能使用
//2.async函数返回的结果必须是一个Future
Future getNetworkData(String str) {
  return Future(() {
    sleep(Duration(seconds: 3));
    return "Hello World!!" + str;
  });
}

控制台打印结果如下：

image.png

await必须在async函数中才能使用；
async函数返回的结果必须是一个Future；
实现多个请求异步执行，回调结果统一处理，案例代码如下：

多核CPU的利用

Isolate

Dart是单线程的，这个线程有自己可以访问的内存空间以及需要运行的事件循环；
我们可以将这个空间系统称之为是一个Isolate；
例如Flutter中就有一个Root Isolate，负责运行Flutter代码，比如UI渲染，用户交互等等；
在Isolate中，资源隔离做的非常好，每个Isolate都有自己的事件循环与事件队列，Isolate之间之间不共享任何资源，只能依靠消息机制进行通信，因此也就没有资源抢占问题，但是如果只有一个Isolate，那么意味着我们只能永远利用一个线程，这对于多核CPU来说，是一种资源的浪费；

Isolate的创建

案例代码：

import 'dart:isolate';

main(List<String> args) {
  print("main start");
  //不会阻塞当前线程 
  Isolate.spawn(calc, 100);

  print("main end");
}

void calc(int count) {
  var total = 0;
  for (var i = 0; i < count; i++) {
    total += I;
  }
  print(total);
}

Isolate的通信机制

创建新的Isolate用于处理耗时操作，然后将耗时操作的结果告知Main Isolate(也就是默认开启的Isolate)；
Isolate通过发送管道(SendPort)实现消息通信机制；
我们可以在启动并发Isolate时将Main Isolate的发送管道作为参数传递给它；
并在执行完毕时，可以利用这个管道给Main Isolate发送消息；
案例代码：

import 'dart:isolate';

main(List<String> args) async {
  print("main start");

  //1.创建管道
  ReceivePort port = ReceivePort();

  //2.创建Isolate
  Isolate isolate = await Isolate.spawn<SendPort>(foo, port.sendPort);

  //3.监听管道
  port.listen((message) {
    print(message);
    //关闭管道
    port.close();
    //Isolate销毁
    isolate.kill();
  });

  print("main end");
}

void foo(SendPort port) {
  return port.send("Hello World");
}

第三方网络请求库

Dio的引入，如下所示：

image.png

在网络请求库Dio的基础上进行封装，创建了http_config.dart与http_request.dart两个文件，如下所示：

class HttpConfig {
  static const String baseUtl = "http://httpbin/org";
  static const int timeout = 5000;
}

import 'package:Fluter01/service/http_config.dart';
import 'package:dio/dio.dart';
import 'package:flutter/cupertino.dart';

class HttpReuquest {
  //基础配置
  static final BaseOptions baseOptions = BaseOptions(baseUrl: HttpConfig.baseUtl,connectTimeout: HttpConfig.timeout);
  //网络请求
  static final Dio dio = Dio(baseOptions);

  static Future<T> request<T>(String url,{String method = "get",Map<String,dynamic> params,Interceptor interceptor}) async{
    //配置
    final options = Options(method: method);

    //全局拦截器
    Interceptor dInterceptor = InterceptorsWrapper(
        onRequest: (options){
          print("请求拦截");
          return options;
        },
        onResponse: (response) {
          print("响应拦截");
          return response;
        },
        onError: (error){
          print("错误拦截");
          return error;
        }
    );

    List<Interceptor> inters = [dInterceptor];

    //单独设置的拦截器
    if (interceptor != null){
      inters.add(interceptor);
    }

    dio.interceptors.addAll(inters);

    //发送网络请求
    try {
      Response response = await dio.request(url,queryParameters: params,options: options);
      return response.data;
    } on DioError catch(e) {
      return Future.error(e);
    }
  }
}

使用封装的网络请求类：

import 'package:flutter/material.dart';
import 'package:Fluter01/service/http_request.dart';

void main() => runApp(SFMyApp());

class SFMyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(home: SFHomePage());
  }
}

class SFHomePage extends StatefulWidget {
  @override
  _SFHomePageState createState() => _SFHomePageState();
}

class _SFHomePageState extends State<SFHomePage> {
  bool isShowFloatButton = false;

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text("基础widget")),
      body: SFHomeContent(),
      floatingActionButton: isShowFloatButton
          ? FloatingActionButton(
              child: Icon(Icons.arrow_upward),
              onPressed: () {

              },
            )
          : null,
    );
  }
}

class SFHomeContent extends StatefulWidget {
  @override
  _SFHomeContentState createState() => _SFHomeContentState();
}

class _SFHomeContentState extends State<SFHomeContent> {

  @override
  void initState() {
    super.initState();

    //发送网络请求
    // ///1.创建dio对象
    // final dio = Dio();
    // ///2.发送网络请求
    // dio.get("http://httpbin.org/get").then((value) {
    //   print(value);
    // });
    
    HttpReuquest.request("http://httpbin.org/get",params: {"name" : "liyanyan"}).then((value) {
      print(value);
    });
    
    
  }

  @override
  Widget build(BuildContext context) {
    return NotificationListener(
      onNotification: (ScrollNotification notification){
        if(notification is ScrollStartNotification){
          print("开始滚动");
        }else if (notification is ScrollUpdateNotification){
          print("正在滚动 -- 总区域:${notification.metrics.maxScrollExtent} 当前位置: ${notification.metrics.pixels}");
        }else if (notification is ScrollEndNotification){
          print("结束滚动");

        }
        return true;
      },
      child: ListView.builder(
        itemBuilder: (BuildContext ctx, int index) {
          return ListTile(
            leading: Icon(Icons.people),
            title: Text("联系人$index"),
          );
        },
        itemCount: 100,
      ),
    );
  }
}

Dart入门07 -- 异步

阻塞式调用与非阻塞式调用

Dart事件循环

Dart的异步操作

Future

await 与 async

多核CPU的利用

Isolate

Isolate的创建

Isolate的通信机制

第三方网络请求库

相关文章

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读