Flutter入门到进阶Dart进阶篇---多线程异步Isolate

1 Isolate 

1.1 什么是Isolate

1.1.1 概念

        线程？异步？隔离？到底什么意思？

        Isolate中文意思是隔离，从使用角度来说是Dart的线程，但是从本质虚拟机的实现角度来讲Isolate是一组封装。

        isolate可以理解为dart中的线程，但它又不同于线程，准确的说应该叫做协程，协程最大的优势就是它具有极高的执行效率，因为协程中子程序的调用不需要线程的切换，所以对于线程数量越大的程序来说协程的优势就越明显。每个isolate都有自己独立的执行线程和事件循环，以及内存，所以isolate之间不存在锁竞争的问题，各个isolate之间通过消息通信。

1.1.2 图例

1.1.3 设计目的

        首先说目前由移动端页面（包含Android、iOS、Web）构建的特性—树形结构构建布局、布局解析抽象、绘制、渲染，这一系列的复杂步骤导致必须在同一个线程完成。因为多线程操作页面UI元素会有并发的问题，有并发就必须要加锁，加锁就会降低执行效率。所以强制在同一线程中操作UI是最好的选择。况且在Flutter中，开发者面对的只有一个主Isolate，在Isolate中可以通过事件队列来实现异步(网络请求、文件IO)等。

1.1.4 说明

        1.为了达到设计目的，采取隔离设计去掉锁的应用

        2.锁去掉后，线程间的信息通信需要建立通信机制来完成，参考linux os 底层策略上来讲本质上就是走IO那套体系来完成

1.2 Isolate本质

1.1.1 图例

1.1.2 说明

        Dart本身抽象了isolate和thread，实际上底层还是使用操作系统的提供的OSThread。

1.3 Isolate组成

1.3.1 Stack用于存放函数调用上下文和调用链路信息。

1.3.2 Heap用于存放对象，堆内存回收管理和java类似。

1.3.3 Queue用于存放异步回调，分为微事件队列（MicroTaskQueue）和微任务队列（EventQueue）。

1.3.4 EventLoop用于处理异步回调。

1.4 Isolate底层逻辑

1.4.1 说明

        虽然在内存表现上，Isolate内存隔离性像是进程的特点。但是从实现上不可能把Isolate作为一个进程，因为进程太重了，每新建一个进程，内核系统都会为新进程创建独立的虚拟内存，保存进程相关的数据结构，并且进程切换效率比较低。所以从可行性上来说Isolate的本质应该是一个线程。也就是说Isolate是通过线程实现的。我们使用多个Isolate也就是使用多个线程，只不过与传统线程不同的是，Isolate之间内存不共享，但可以通过通信机制互通。

1.4.2 Isolate如何实现内存隔离

1.  
   // vm/isolate.cc Isolate* 
2.  
   Isolate::InitIsolate(
3.  
   const char* name_prefix,                               
4.  
   IsolateGroup* isolate_group,                               
5.  
   const Dart_IsolateFlags& api_flags,                               
6.  
   bool is_vm_isolate) {   
7.  
   Isolate* result = new Isolate(isolate_group, api_flags);   
8.  
   ...        
9.  
   Heap::Init(result,              
10.  
    is_vm_isolate? 0  
11.  
    // New gen size 0; VM isolate should only allocate in old.                  
12.  
    : FLAG_new_gen_semi_max_size * MBInWords,              
13.  
    (is_service_or_kernel_isolate ? kDefaultMaxOldGenHeapSize
14.  
    : FLAG_old_gen_heap_size) 
15.  
    *MBInWords);                       
16.  
    ...       
17.  
    }

        从代码中可以看Isolate的堆内存也被区分为新生代和老年代两块区域，Dart虚拟机针对不同的区域执行不同的垃圾回收策略：

        新生代采用复制清除算法，针对频繁创建销毁的页面控件对象，可以从内存层面实现快速分配和回收。

        老年代采用标记清除和标记整理两种算法，来适应不同的内存回收场景，尽量保证UI的流畅性。

        这里也就解释了Dart中内存分配模型，和高效垃圾的回收机制。

1.5 运行图例

1.6 Isolate模式

在dart中编写的代码分为两种类型

1.6.1 同步模式

即正常编写的代码。  

        BIO模式

1.6.2 异步模式

一些返回类型为Future和Stream的函数。   

        NIO模式

1.7 Isolate使用案例

1.7.1 常规使用

1.  
   import 'dart:isolate';
2.  
   void main(){   
3.  
   print("main begin");   
4.  
   Isolate.spawn((message) {     
5.  
   print("匿名函数线程：$message");   
6.  
   }, "inner msg...");   
7.  
   Isolate.spawn(newThread1, "hello 1");   
8.  
   Isolate.spawn(newThread2, "hello 2");   
9.  
   Isolate.spawn(newThread3, "hello 3");   
10.  
    print("main end");
11.  
    }
12.  
    void newThread1(String msg){   
13.  
    print("Thread 1 msg:$msg");
14.  
    }
15.  
    void newThread2(String msg){   
16.  
    print("Thread 2 msg:$msg");
17.  
    }
18.  
    void newThread3(String msg){   
19.  
    print("Thread 3 msg:$msg");
20.  
    }

1.7.2 isolate.spwanUri

1.  
   //当前文件
2.  
    
3.  
   import 'dart:isolate';
4.  
   ///isolate spawnUri方式
5.  
   void main() {   
6.  
   print("main begin");   
7.  
   test1();   
8.  
   newThread();   
9.  
   test2();   
10.  
    print("main end");
11.  
    }
12.  
    void test1(){   
13.  
    print("test1.....");
14.  
    }
15.  
    void test2(){   
16.  
    print("test2.....");
17.  
    }
18.  
    ///参数的定义可以随意，参数中接收的SendPort是需要通信的发送端口
19.  
    @sendPort
20.  
    void newThread(){   
21.  
    print("新线程.....");   
22.  
    ReceivePort receivePort = ReceivePort();   
23.  
    SendPort sendPort = receivePort.sendPort;   
24.  
    Isolate.spawnUri(Uri(path: "./isolate_spawnUri_task.dart"),["msg1","msg2","msg3"], sendPort);   
25.  
    //监听   
26.  
    receivePort.listen((message) {     
27.  
    print("主线程接收到来自子线程消息：${message}");     
28.  
    switch(message[1]){       
29.  
    case 0:         
30.  
    //子线程正在处理初始化数据...         
31.  
    print("接收到初始化消息");         
32.  
    break;       
33.  
    case 1:         
34.  
    //子线程异步数据正在处理中..         
35.  
    print("接收到处理中状态消息");         
36.  
    break;       
37.  
    case 2:         
38.  
    //子线程数据处理完整         
39.  
    print("接收到任务完成消息");         
40.  
    receivePort.close();        
41.  
    break;     
42.  
    }   
43.  
    });
44.  
    }
45.  
     
46.  
     
47.  
    //目标文件
48.  
     
49.  
    import 'dart:isolate';
50.  
    import 'dart:io';
51.  
    ///isolate spawnUri方式
52.  
    void main(List<String> args,SendPort sendPort) {   
53.  
    print("isolate_spawnUri_task.dart begin");   
54.  
    print("接收到相关参数：$args");   
55.  
    sendPort.send(["开始执行异步操作",0]);   
56.  
    sleep(Duration(seconds: 2));   
57.  
    sendPort.send(["加载数据中...",1]);   
58.  
    sleep(Duration(seconds: 2));   
59.  
    sendPort.send(["异步任务完成",2]);   
60.  
    sleep(Duration(seconds: 2));   
61.  
    print("isolate_spawnUri_task.dart end");
62.  
    }

1.8 Isolate通信

1.8.1 说明

        创建Isolate时需要指定一个接收端口（ReceivePort）的发送端口（SendPort），调用者可以通过这个发送端口发送数据到其他的Isolate中ReceivePort的listen中，这种机制被称为消息传递(message passing)

        既然是内存隔离的，那么在调用者所在Isolate发送的消息数据是怎么传递到接收者所在的Isolate中的呢？也就是说Isolate通信的底层逻辑是什么呢？

        答案是map_变量，map_是一个Hash列表。是在Dart虚拟启动时初始化的，所以map_变量是存在于Dart虚拟机所属内存的，而这块内存是各个Isolate共享的。

1.8.2 通信

1.  
   import 'dart:isolate';
2.  
    
3.  
   ///isolate 通信 - 单向
4.  
   void main() async{
5.  
     print("main begin");
6.  
    
7.  
     ReceivePort receivePort = ReceivePort();
8.  
     Isolate.spawn(newThread,["你好",receivePort.sendPort]);
9.  
     //方案1：通过listen进行监听
10.  
      // receivePort.listen((message) {
11.  
      //   print("listen方式-主线程接收到消息：$message");
12.  
      // });
13.  
      //方案2：通过 await关键字与async关键字建立阻塞通道
14.  
      var msg = await receivePort.first;
15.  
      //上面这两种方案上只选选择一种处理
16.  
      //原因：这里dart对于数据的等待接收，我们可以看做为socket的BIO与NIO
17.  
      //listen方案实际上就是利用select，epoll这种方案在进行循环监听
18.  
      //await 就是read的阻塞式等待
19.  
     
20.  
     
21.  
      print("await方式-主线程接收到消息：$msg");
22.  
      print("main end");
23.  
    }
24.  
     
25.  
     
26.  
    ///参数的定义可以随意，参数中接收的SendPort是需要通信的发送端口
27.  
    ///@sendPort
28.  
    void newThread(var message){
29.  
      String msg = message[0];
30.  
      SendPort sendPort = message[1];
31.  
      print("通过参数传递的数据1：$msg");
32.  
     
33.  
      //通过传递过来的sendPort给主线程回消息
34.  
      sendPort.send("这个是子线程给主线程回的消息！！！");
35.  
    }

1.8.3 为什么将Isolate设计成隔离的

        1、首先说目前由移动端页面（包含Android、iOS、Web）构建的特性—树形结构构建布局、布局解析抽象、绘制、渲染，这一系列的复杂步骤导致必须在同一个线程完成。**因为多线程操作页面UI元素会有并发的问题，有并发就必须要加锁，加锁就会降低执行效率。所以强制在同一线程中操作UI是最好的选择。**况且在Flutter中，开发者面对的只有一个主Isolate，在Isolate中可以通过事件队列来实现异步(网络请求、文件IO)等。所以不需要再使用其他线程完成异步。

        2、每当有页面交互时，必定会引起布局变化而重新绘制，这个过程会有频繁的大量的UI控件的创建和销毁，这就涉及到了耗时内存分配和回收。而这些较短生命周期的对象是存放在堆内存的新生代的，当虚拟机回收新生代内存时是要stop the world的，在Android或iOS中，各个线程共用一块堆内存，当非UI线程频繁申请、释放内存时也会触发垃圾回收，所以会间接影响UI线程的运行。

        Dart为了解决这个问题，就每个Isolate（看做线程）分配各自的一块堆内存，并且独自管理内。这样的策略使得内存的分配和回收变得简单高效，并且不受其他Isolate的影响。

1.9 总结

        1、Dart中向应用层提供了线程的封装——Isolate。应用层是不能创建线程的，只能使用Isolate

        2、Isolate与传统的线程不同的是，内存隔离

        3、Isolate设计成隔离的，是出于移动端页面UI构建特性考虑。第一点，UI绘制必须在同一线程内完成，所以强制同一线程是最好的选择。第二点，传统的线程内存共享，其他线程频繁的申请释放内存会触发垃圾回收，间接影响UI线程运行

2 Dart io 

2.5 用Stream读取文件：

        使用Stream读取文件，一次读取一点。你可以使用Stream API或await for。

代码

1.  
   import 'dart:io';
2.  
   import 'dart:convert';
3.  
    
4.  
   Future<void> main() async {
5.  
     var config = File('config.txt');
6.  
     Stream<List<int>> inputStream = config.openRead();
7.  
     var lines = utf8.decoder.bind(inputStream).transform(const LineSplitter());
8.  
     try {
9.  
       await for (final line in lines) {
10.  
          print('Got ${line.length} characters from stream');
11.  
        }
12.  
        print('file is now closed');
13.  
      } catch (e) {
14.  
        print(e);
15.  
      }
16.  
    }

var sink = logFile.openWrite(mode: FileMode.append)

2.7 列出目录中的文件

        查找目录的所有文件和子目录是一项异步操作。方法返回遇到文件或目录时对象的Stream。

代码

1.  
   Future<void> main() async {
2.  
     var dir = Directory('tmp');
3.  
     try {
4.  
       var dirList = dir.list();
5.  
       await for (final FileSystemEntity f in dirList) {
6.  
         if (f is File) {
7.  
           print('Found file ${f.path}');
8.  
         } else if (f is Directory) {
9.  
           print('Found dir ${f.path}');
10.  
          }
11.  
        }
12.  
      } catch (e) {
13.  
        print(e.toString());
14.  
      }
15.  
    }

这篇好文章是转载于：学新通技术网