Flutter开发系列(三)--Dart异步机制与异步编程

  Dart是单线程语言,但是请求网络,数据操作和IO操作等耗时操作需要异步,否则可能会导致无响应。Isolate机制是Dart中的异步机制。与Java中的线程不同,Isolate中的线程(可以先称之为线程)是内存隔离的(像进程一样的线程),而Java中的线程是内存共享的。

  Dart中的main函数启动时会启动一个进程(可先称之为主线程,或者主isolate)。使用Isolate.spawn可以创建一个新的Isolate。

import 'dart:io';
import 'dart:isolate';

int i;

void main() {
    i = 2;
    Isolate.spawn(entryPoint, "hello");//开启一个子Isolate
}

//entryPoint相当于在一个新的子线程中执行
void entryPoint(Stirng message) {
    print(i); //输出为null,而非2,也说明了主isolate与子isolate内存隔离,无法共享
    sleep(Duration(seconds: 10)); //子isolate延迟,不会影响主isolate
    print(message);
}

    消息接收器和消息发送器即ReceivePort和SendPort,它们在每个isolate中均存在,并且只有同一个isolate中的ReceivePort才能接受到其SendPort发送的消息并进行处理。

void main() {
    //创建一个消息接收器
    var receivePort = new ReceivePort();

    //从消息接收器读取消息
    //消息接收器添加监听,监听接收的消息是发送器发送过来的
    receivePort.listen((t) {
        print(t);
    });

    //发送消息
    receivePort.sendPort.send("1");
    receivePort.sendPort.send("2");
    receivePort.sendPort.send(1);

    //使用完毕关闭消息接收器
    receivePort.close();
}

主isolate和子isolate之间如何通信? -- 通过SendPort和ReceivePort

1、主线程中创建消息接收器

void main() {
    //创建一个消息接收器
    var receivePort = new ReceivePort();

    //开启一个子isolate,并将主isolate消息接收器中的发送器发给子isolate
    Isolate.spawn(entryPoint, receivePort.sendPort);

    //消息接收器添加监听
    receiverPort.listen((t) {
        print(t); //主isolate接收到子isolate中发送的消息
    });
}

void entryPoint(SendPort sendPort) {
    sendPort.send("111"); //在子isolate中使用发送器发送消息
}

2、子线程中创建消息接收器

void entryPoint(SendPort sendPort) {
    var receivePort = new ReceivePort();
    var sendPort2 = receivePort.sendPort; //子isolate的消息发送器
    sendPort.send(sendPort2);

    receivePort.listen((t) { //子isolate接收主isolate发送的消息

    });
}

void main() {
    var receivePort = new ReceivePort();
    Isolate.spawn(entryPoint, receivePort.sendPort);

    receivePort.listen((t) {
        print("接收到其他isolate发送过来的消息!");
        //主isolate中接收到子isolate中的消息发送器
        if(t is SendPort) {
            //to do
        }
    });
}

Dart中每一个isolate都相当于一个独立的执行环境。消息驱动机制存在于Dart的isolate中,每一个isolate中都有一个独立的完整的event-loop任务队列。这种消息驱动机制与Android中的消息驱动机制类似,不同的是,Dart中有两个消息队列,一个是普通事件队列(event queue),另一个是微任务队列(microtask queue)。Dart执行完main函数之后,就会通过loop开始执行两个任务队列中的事件。Loop首先检查微任务队列,依次执行微任务队列中的event;当微任务队列执行完之后,检查event queue队列依次执行,在执行event queue过程中,每执行完一个event就再检查一次微任务队列。故微任务队列的优先级较高,我们可以利用微任务队列进行消息插队。

void main() {
    var receivePort = new ReceivePort();
    receivePort.listen((t) {
        print(t);
    });

    //使用Future.microtask往微任务队列中提交一个消息
    Future.microtask(() {
        print("微任务执行--1");
    });

    receivePort.sendPort.send("发消息给消息接收器--1");

    Future.microtask(() {
        print("微任务执行--2");
    });

    receivePort.sendPort.send("发消息给消息接收器--2");

    Future.microtask(() {
        print("微任务执行--3");
    });

    receivePort.sendPort.send("发消息给消息接收器--3");
}

上述示例代码会先打印微任务执行,再打印普通任务消息,说明微任务队列的优先级较高,输出为

微任务执行--1
微任务执行--2
微任务执行--3
发消息给消息接收器--1
发消息给消息接收器--2
发消息给消息接收器--3

因为Dart是单线程模型,消息队列在同一isolate中。如果微任务队列执行后延迟了几秒,则后续的任务均会延迟执行。

我们平时执行的任务大部分是在event-queue中。Dart中存在插队机制,如果我们希望某个任务优于其他任务执行,可以使用微任务队列进行插队执行。

void main() {
    var receivePort = new ReceivePort();
    receivePort.listen((t) {
        print(t);
        Future.microtask(() {
            print("微任务执行");
        });
    });

    receivePort.sendPort.send("发消息给消息接收器1");
    receivePort.sendPort.send("发消息给消息接收器2");
    receivePort.sendPort.send("发消息给消息接收器3");

    //main函数执行延迟10s,消息队列执行也会延迟10s,也即任务队列是在main函数执行完毕之后执行的
    sleep(Duration(second: 10)); //main函数不是由消息队列执行,此行未加入到消息队列中
}

上述示例代码利用微任务队列实现插队,执行结果为

发消息给消息接收器1
微任务执行
发消息给消息接收器2
微任务执行
发消息给消息接收器3
微任务执行

在Flutter编程中使用更多的是FutureStream

在Java开发中进行并发编程时,会用到Future来获取异步任务执行的结果。在Dart中我们执行一个任务也可以使用Future来完成。Future表示未来执行的任务,是在任务队列中提取任务来执行。Future默认执行的event-queue普通任务队列中的任务,也可以提交任务到微任务队列。Future提供的api中绝大部分是用来执行普通任务的,如:wait(), forEach(), doWhile(), delayed(), any(), error()...,但可以通过Future.microtask()提交一个微任务。

//Future基本使用
void main() {
    Future f = Future.delayed(Duration(seconds: 3)); //将延迟任务放到任务队列中
    f.then((t) { //通过then可以获取future的执行结果
        print(t);
    });
}

对于网络请求或文件操作,java一般将其放在一个子线程中去执行。而在Dart中进行文件IO操作是十分方便的,直接调用对应的异步方法即可。如File相关函数readAsString()、readAsBytes()、readAsLines()等,另外还有对应的同步方readAsStringSync()、readAsBytesSync()、readAsLinesSync()等。例如:

void main() {
    new File(r"c:\test.txt").readAsString()  //读取文件中内容,返回future类对象
                            .then((String s) { //这里获取结果类型确认为String
                                print(s);  //打印读取的字符串
                             })
                            .catchError((s, e) {  //捕获异常
                             });

    Future.delayed(Duration(seconds: 10)); //延迟任务。上一个任务异常会导致后续的任务无法执行
}

then方法返回后可以得到Future任务执行的结果并且返回一个新的Future对象:

void main() {
    Future<int> then = new File(r"c:\test.txt").readAsString().then((String s) {
                                                    print(s); //打印读取的字符串
                                                    return 10; //这里添加返回值
                                                });

    then.then((int i) {
             print(i); //这里打印结果为10
         });
}

或者直接使用链式调用的方式写成如下形式:

void main() {
    Future<int> then = new File(r"c:\test.txt").readAsString().then((String s) {
                                                    print(s); //打印读取的字符串
                                                    return 10;
                                                }).then((int i) {
                                                    print(i); //10
                                                });
}

这里和rxjava中的写法相似,也是返回一个同类型的对象,使用链式调用的方式。 

使用Future.then可以完成有序任务的执行,即前一个任务执行完毕,后一个任务根据前一个任务的结果执行后续的操作。如果要实现一组任务执行完之后再统一执行后续的操作,可以使用Future.wait():

void main() {
    Future.wait([Future.delayed(seconds: 5), 
                 Future.delayed(seconds: 10)]).then((_) {
                                                   print(1);
                                               });
}

Stream:

Stream在Dart中也经常出现,表示发出的一系列异步数据,同样可以用于异步操作。Future表示稍后获得的一个数据,所有异步的操作返回值均用Future表示。它与Future的区别在于,Future表示一次异步获得的数据,Stream表示需要多次异步操作获得的结果。Stream的好处是处理过程中内存占用较小。

void main() {
    var stream = new File(r"c:\test.txt").openRead(); //返回Stream<List<int>>,泛型类型是<List<int>>
    stream.listen((s) {
        print(1); //如果文件较大,会读取多次,但Future会一次性读取完毕
    });
}

Stream.listen()其实就是去订阅这个Stream,它返回一个StreamSubscription类型的订阅者对象。订阅者提供了一些方法方便我们执行订阅的相关操作,如cancel()用于取消监听读取过程,这样listen中就无法接收到任何信息了,onData()可以重置listen方法,onDone()监听读取完毕,pause()和resume()可以停止和恢复监听等。

void main() {
    StreamSubscription<List<int>> listen = new File(r"c:\test.txt").openRead()
                                               .listen((List<int> bytes) {
                                                    print("stream执行");
                                                });
    listen.onData((_) {
        print("替换listen");
    });
    listen.onDone(() {
        print("结束");
    });
    listen.pause(); //暂停,如果没有继续,程序退出
    listen.resume();
}

Stream广播模式:

Stream有两种订阅模式:单订阅模式和多订阅模式。Stream默认是单订阅模式,即只能有一个订阅者,若有多个订阅者会报错。前述使用的都是单订阅模式。而广播模式可以有多个订阅者,通过Stream.asBroadcastStream()可以将一个单订阅模式的stream转换为一个多订阅模式的stream,通过isBroadcast属性可以判断当前stream所属的模式。

void main() {
    var stream = new File(r"c:\test.txt").openRead();
    stream.listen((List<int> bytes) {
                     print("stream执行");
                  });
    //如下会报错,单订阅模式只能有一个订阅者
    //stream.listen((_) {
    //                 print("stream执行2");
    //              });

    //如下会报错 ,单订阅的stream如果已经添加了订阅者,则不能再转换成广播模式了
    //var streamBroadcast = stream.asBroadcastStream();

    var streamBroadcast = new File(r"c:\test.txt").openRead().asBroadcastStream();
    streamBroadcast.listen((_) {
        print("订阅者1");
    });
    streamBroadcast.listen((_) {
        print("订阅者2");
    });
    streamBroadcast.listen((_) {
        print("订阅者3");
    });
}

Stream的广播模式除了通过上述使用单订阅模式转换的方式,还可以使用StreamController直接创建广播:

void main() {
    //创建一个广播,对stream进行管理
    var streamController = StreamController.broadcast();
    //添加一个事件 即发送一条广播
    streamController.add("11");
    //监听
    //先发出事件再订阅,无法收到通知
    streamController.stream.listen((i) {
        print("广播:$i");
    });

    //使用完关闭
    streamController.close();

    //--------------------------------------------
    var stream = Stream.forIterable([1, 2, 3, 4]);
    //单订阅转换的广播消息发出后再监听也是可以收到消息的
    var broadcastStream = stream.asBroadcastStream();
    broadcastStream.listen((i) {
        print("订阅者:${i}");
    });

    new Timer(Duration(seconds: 3), ()=> {
        broadcastStream.listen((i) {
            print("订阅者2:${i}"); //也可以收到消息
        });
    });
}

广播模式下无法接收到订阅前的消息,而通过单订阅模式转换的广播先发送再注册是可以接收到消息的,利用此特性可以实现粘性广播。

StreamController实现了StreamSink,而StreamSink实现了EventSink,EventSink有add,addError,close等方法,EventSink实现了sink,EventSink和Sink均是抽象类,Sink只有add(发出一个广播)和close(关闭)两个方法。

asyncawait

这是Dart中的两个关键字,使用async和await的代码表示是异步执行的。

//async表示这是一个异步方法,异步方法只能返回void和Future
//await必须在async方法中使用
Future<String> readFile() async {
    //await 等待future执行完之后再执行后续的代码,即实现了同步的效果,其作用类似then方法,可以避免then方法回调地狱
    String content = await new File("/path/test.txt").readAsString();
    String content2 = await new File("/path/test.txt").readAsString();
    String content3 = await new File("/path/test.txt").readAsString();
    //自动转换为Future
    return content;
}

void main() {
  new File("/path/test.txt").readAsString(); //这里读取文件不是同步的。
  new File("/path/test.txt").readAsString();
}

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值