精华内容
下载资源
问答
  • Dart Isolate

    2019-12-27 17:04:36
    将非常耗时的任务添加到事件队列后,仍然会拖慢整个事件循环的处理,甚至是阻塞。可见基于事件循环的异步模型仍然是有很大缺点的,这时候我们就需要Isolate

    Dart汇总请点击这里

    Isolate概述

    将非常耗时的任务添加到事件队列后,仍然会拖慢整个事件循环的处理,甚至是阻塞。可见基于事件循环的异步模型仍然是有很大缺点的,这时候我们就需要Isolate

    简单说,可以把它理解为Dart中的线程。但它又不同于线程,更恰当的说应该是微线程,或者说是协程。它与线程最大的区别就是不能共享内存,因此也不存在锁竞争问题,两个Isolate完全是两条独立的执行线,且每个Isolate都有自己的事件循环,它们之间只能通过发送消息通信,所以它的资源开销低于线程。

    isolate本身是隔离的意思,有自己的内存和单线程控制的实体,因为isolate之间的内存在逻辑是隔离的,isolate的代码是按顺序执行的。在Dart中并发可以使用用isolate,isolate和Thread很像,但是isolate之间没有共享内存。一个Dart程序是在Main isolate的Main函数开始,我们平时开发中,默认环境就是Main isolate,App的启动入口main函数就是一个isolate,在Main函数结束后,Main isolate线程开始一个一个处理Event Queue中的每一个Event。

    从主Isolate创建一个新的Isolate

    spawnUri

    static Future<Isolate> spawnUri()
    

    spawnUri方法有三个必须的参数,

    • 第一个是Uri,指定一个新Isolate代码文件的路径,
    • 第二个是参数列表,类型是List,
    • 第三个是动态消息。

    需要注意,用于运行新Isolate的代码文件中,必须包含一个main函数,它是新Isolate的入口方法,该main函数中的args参数列表,正对应spawnUri中的第二个参数。如不需要向新Isolate中传参数,该参数可传空List

    主Isolate中的代码:

    import 'dart:isolate'; 
    
    void main() {
      print("main isolate start");
      create_isolate();
      print("main isolate stop");
    }
    
    // 创建一个新的 isolate
    create_isolate() async{
      ReceivePort rp = new ReceivePort();
      SendPort port1 = rp.sendPort;
    
      Isolate newIsolate = await Isolate.spawnUri(new Uri(path: "./other_task.dart"), ["hello, isolate", "this is args"], port1);
    
      SendPort port2;
      rp.listen((message){
        print("main isolate message: $message");
        if (message[0] == 0){
          port2 = message[1];
        }else{
          port2?.send([1,"这条信息是 main isolate 发送的"]);
        }
      });
    
      // 可以在适当的时候,调用以下方法杀死创建的 isolate
      // newIsolate.kill(priority: Isolate.immediate);
    }
    

    创建other_task.dart文件,编写新Isolate的代码

    import 'dart:isolate';
    import  'dart:io';
    
    
    void main(args, SendPort port1) {
      print("isolate_1 start");
      print("isolate_1 args: $args");
    
      ReceivePort receivePort = new ReceivePort();
      SendPort port2 = receivePort.sendPort;
    
      receivePort.listen((message){
        print("isolate_1 message: $message");
      });
    
      // 将当前 isolate 中创建的SendPort发送到主 isolate中用于通信
      port1.send([0, port2]);
      // 模拟耗时5秒
      sleep(Duration(seconds:5));
      port1.send([1, "isolate_1 任务完成"]);
    
      print("isolate_1 stop");
    }
    

    运行主Isolate的结果:

    main isolate start
    main isolate stop
    isolate_1 start
    isolate_1 args: [hello, isolate, this is args]
    main isolate message: [0, SendPort]
    isolate_1 stop
    main isolate message: [1, isolate_1 任务完成]
    isolate_1 message: [1, 这条信息是 main isolate 发送的]
    

    两个Isolatet通信原理

    在这里插入图片描述

    整个消息通信过程如上图所示:

    两个Isolate是通过两对Port对象通信,一对Port分别由用于接收消息的ReceivePort对象,和用于发送消息的SendPort对象构成。其中SendPort对象不用单独创建,它已经包含在ReceivePort对象之中。需要注意,一对Port对象只能单向发消息,这就如同一根自来水管,ReceivePort和SendPort分别位于水管的两头,水流只能从SendPort这头流向ReceivePort这头。因此,两个Isolate之间的消息通信肯定是需要两根这样的水管的,这就需要两对Port对象。

    Dart代码中,具体是如何Isolate通信

    ReceivePort对象通过调用listen方法,传入一个函数可用来监听并处理发送来的消息。SendPort对象则调用send()方法来发送消息。send方法传入的参数可以是null,num, bool, double,String, List ,Map或者是自定义的类。 在上例中,我们发送的是包含两个元素的List对象,第一个元素是整型,表示消息类型,第二个元素则表示消息内容。

    spawn

    static Future spawn()
    除了使用spawnUri,更常用的是使用spawn方法来创建新的Isolate,我们通常希望将新创建的Isolate代码和main Isolate代码写在同一个文件,且不希望出现两个main函数,而是将指定的耗时函数运行在新的Isolate,这样做有利于代码的组织和代码的复用。spawn方法有两个必须的参数,第一个是需要运行在新Isolate的耗时函数,第二个是动态消息,该参数通常用于传送主Isolate的SendPort对象。

    spawn的用法与spawnUri相似,且更为简洁,将上面例子稍作修改如下

    import 'dart:isolate'; 
    import  'dart:io';
    
    void main() {
      print("main isolate start");
      create_isolate();
      print("main isolate end");
    }
    
    // 创建一个新的 isolate
    create_isolate() async{
      ReceivePort rp = new ReceivePort();
      SendPort port1 = rp.sendPort;
    
      Isolate newIsolate = await Isolate.spawn(doWork, port1);
    
      SendPort port2;
      rp.listen((message){
        print("main isolate message: $message");
        if (message[0] == 0){
          port2 = message[1];
        }else{
          port2?.send([1,"这条信息是 main isolate 发送的"]);
        }
      });
    }
    
    // 处理耗时任务
    void doWork(SendPort port1){
      print("new isolate start");
      ReceivePort rp2 = new ReceivePort();
      SendPort port2 = rp2.sendPort;
    
      rp2.listen((message){
        print("doWork message: $message");
      });
    
      // 将新isolate中创建的SendPort发送到主isolate中用于通信
      port1.send([0, port2]);
      // 模拟耗时5秒
      sleep(Duration(seconds:5));
      port1.send([1, "doWork 任务完成"]);
    
      print("new isolate end");
    }
    

    运行结果:

    main isolate start
    main isolate end
    new isolate start
    main isolate message: [0, SendPort]
    new isolate end
    main isolate message: [1, doWork 任务完成]
    doWork message: [1, 这条信息是 main isolate 发送的]
    

    无论是上面的spawn还是spawnUri,运行后都会创建两个进程,一个是主Isolate的进程,一个是新Isolate的进程,两个进程都双向绑定了消息通信的通道,即使新的Isolate中的任务完成了,它的进程也不会立刻退出,因此,当使用完自己创建的Isolate后,最好调用newIsolate.kill(priority: Isolate.immediate);将Isolate立即杀死。

    Flutter中创建Isolate

    无论如何,在Dart中创建一个Isolate都显得有些繁琐,可惜的是Dart官方并未提供更高级封装。但是,如果想在Flutter中创建Isolate,则有更简便的API,这是由Flutter官方进一步封装ReceivePort而提供的更简洁API。详细API文档

    使用compute函数来创建新的Isolate并执行耗时任务

    import 'package:flutter/foundation.dart';
    import  'dart:io';
    
    // 创建一个新的Isolate,在其中运行任务doWork
    create_new_task() async{
      var str = "New Task";
      var result = await compute(doWork, str);
      print(result);
    }
    
    
    void doWork(String value){
      print("new isolate doWork start");
      // 模拟耗时5秒
      sleep(Duration(seconds:5));
    
      print("new isolate doWork end");
      return "complete:$value";
    }
    

    compute函数有两个必须的参数,

    • 第一个是待执行的函数,这个函数必须是一个顶级函数,不能是类的实例方法,可以是类的静态方法,
    • 第二个参数为动态的消息类型,可以是被运行函数的参数。
      需要注意,使用compute应导入’package:flutter/foundation.dart’包。

    使用场景
      Isolate虽好,但也有合适的使用场景,不建议滥用Isolate,应尽可能多的使用Dart中的事件循环机制去处理异步任务,这样才能更好的发挥Dart语言的优势。

    那么应该在什么时候使用Future,什么时候使用Isolate呢?

    一个最简单的判断方法是根据某些任务的平均时间来选择:

    方法执行在几毫秒或十几毫秒左右的,应使用Future,如果一个任务需要几百毫秒或之上的,则建议创建单独的Isolate
    除此之外,还有一些可以参考的场景

    • JSON 解码
    • 加密
    • 图像处理:比如剪裁
    • 网络请求:加载资源、图片
    展开全文
  • dart isolate demo

    2019-01-28 12:09:00
    import 'dart:async'; import 'dart:isolate'; main() async { var receivePort = new ReceivePort(); await Isolate.spawn(echo, receivePort.sendPort); // The 'echo' isolate send...
        
    import 'dart:async';
    import 'dart:isolate';
    
    main() async {
      var receivePort = new ReceivePort();
      await Isolate.spawn(echo, receivePort.sendPort);
    
      // The 'echo' isolate sends it's SendPort as the first message
      var sendPort = await receivePort.first;
    
      var msg = await sendReceive(sendPort, "foo");
      print('received $msg');
      msg = await sendReceive(sendPort, "bar");
      print('received $msg');
    }
    
    // the entry point for the isolate
    echo(SendPort sendPort) async {
      // Open the ReceivePort for incoming messages.
      var port = new ReceivePort();
    
      // Notify any other isolates what port this isolate listens to.
      sendPort.send(port.sendPort);
    
      await for (var msg in port) {
        var data = msg[0];
        SendPort replyTo = msg[1];
        replyTo.send(data);
        if (data == "bar") port.close();
      }
    }
    
    /// sends a message on a port, receives the response,
    /// and returns the message
    Future sendReceive(SendPort port, msg) {
      ReceivePort response = new ReceivePort();
      port.send([msg, response.sendPort]);
      return response.first;
    }
    

    运行方法,在命令行中

    dart isolate_demo.dart
    $ dart isolate_demo.dart 
    received foo
    received bar
    
    
    展开全文
  • 闲鱼技术-福居本文结合Flutter Engine官方文档讨论了Flutter Engine内的线程管理模式以及Dart Isolate机制。 Flutter 是什么? Flutter简介 Flutter是Google主导开发的高质量高性能移动跨平台UI开发套件。使用...

    闲鱼技术-福居
    本文结合Flutter Engine官方文档讨论了Flutter Engine内的线程管理模式以及Dart Isolate机制。

    Flutter 是什么?

    Flutter简介

    Flutter是Google主导开发的高质量高性能移动跨平台UI开发套件。使用Flutter你可以使用Dart语言高效快速开发高质量的跨平台App,同时Flutter还可以可以与现存的Native代码兼容。目前在世界范围内被众多开发者和组织使用,而且它是开源免费的!

    Flutter优势与前景

    目前Flutter拿来比较最多的是Reactive Native,实际上Flutter跟RN有本质的区别。Flutter UI渲染是自己实现,这跟RN JS Bridge的形式有区别。这也是Flutter性能的一个突破点。使用Flutter用开发效率高,运行效率高,UI灵活性扩展性高等特点。相对于JS Bridge扩展型的跨平台实现,Flutter有着更加广阔的想象空间。

    更加详细的介绍可以浏览此链接:Flutter IO

    Flutter 线程管理简述

    Flutter Engine自己不创建管理线程。Flutter Engine线程的创建和管理是由embedder负责的。

    注意:Embeder是指将引擎移植的平台的中间层代码。

    Flutter Engine要求Embeder提供四个Task Runner。尽管Flutter Engine不在乎Runner具体跑在哪个线程,但是它需要线程配置在整一个生命周期里面保持稳定。也就是说一个Runner最好始终保持在同一线程运行。这四个主要的Task Runner包括:

    Flutter Engine运行架构

    Platform Task Runner

    Flutter Engine的主Task Runner,运行Platform Task Runner的线程可以理解为是主线程。类似于Android Main Thread或者iOS的Main Thread。但是我们要注意Platform Task Runner和iOS之类的主线程还是有区别的。

    对于Flutter Engine来说Platform Runner所在的线程跟其它线程并没有实质上的区别,只不过我们人为赋予它特定的含义便于理解区分。实际上我们可以同时启动多个Engine实例,每个Engine对应一个Platform Runner,每个Runner跑在各自的线程里。这也是Fuchsia(Google正在开发的操作引擎)里Content Handler的工作原理。一般来说,一个Flutter应用启动的时候会创建一个Engine实例,Engine创建的时候会创建一个线程供Platform Runner使用。

    跟Flutter Engine的所有交互(接口调用)必须发生在Platform Thread,试图在其它线程中调用Flutter Engine会导致无法预期的异常。这跟iOS UI相关的操作都必须在主线程进行相类似。需要注意的是在Flutter Engine中有很多模块都是非线程安全的。一旦引擎正常启动运行起来,所有引擎API调用都将在Platform Thread里发生。

    Platform Runner所在的Thread不仅仅处理与Engine交互,它还处理来自平台的消息。这样的处理比较方便的,因为几乎所有引擎的调用都只有在Platform Thread进行才能是安全的,Native Plugins不必要做额外的线程操作就可以保证操作能够在Platform Thread进行。如果Plugin自己启动了额外的线程,那么它需要负责将返回结果派发回Platform Thread以便Dart能够安全地处理。规则很简单,对于Flutter Engine的接口调用都需保证在Platform Thread进行。

    需要注意的是,阻塞Platform Thread不会直接导致Flutter应用的卡顿(跟iOS android主线程不同)。尽管如此,平台对Platform Thread还是有强制执行限制。所以建议复杂计算逻辑操作不要放在Platform Thread而是放在其它线程(不包括我们现在讨论的这个四个线程)。其他线程处理完毕后将结果转发回Platform Thread。长时间卡住Platform Thread应用有可能会被系统Watchdot强行杀死。

    UI Task Runner Thread(Dart Runner)

    UI Task Runner被Flutter Engine用于执行Dart root isolate代码(isolate我们后面会讲到,姑且先简单理解为Dart VM里面的线程)。Root isolate比较特殊,它绑定了不少Flutter需要的函数方法。Root isolate运行应用的main code。引擎启动的时候为其增加了必要的绑定,使其具备调度提交渲染帧的能力。对于每一帧,引擎要做的事情有:

    • Root isolate通知Flutter Engine有帧需要渲染。
    • Flutter Engine通知平台,需要在下一个vsync的时候得到通知。
    • 平台等待下一个vsync
    • 对创建的对象和Widgets进行Layout并生成一个Layer Tree,这个Tree马上被提交给Flutter Engine。当前阶段没有进行任何光栅化,这个步骤仅是生成了对需要绘制内容的描述。
    • 创建或者更新Tree,这个Tree包含了用于屏幕上显示Widgets的语义信息。这个东西主要用于平台相关的辅助Accessibility元素的配置和渲染。

    除了渲染相关逻辑之外Root Isolate还是处理来自Native Plugins的消息响应,Timers,Microtasks和异步IO。
    我们看到Root Isolate负责创建管理的Layer Tree最终决定什么内容要绘制到屏幕上。因此这个线程的过载会直接导致卡顿掉帧。
    如果确实有无法避免的繁重计算,建议将其放到独立的Isolate去执行,比如使用compute关键字或者放到非Root Isolate,这样可以避免应用UI卡顿。但是需要注意的是非Root Isolate缺少Flutter引擎需要的一些函数绑定,你无法在这个Isolate直接与Flutter Engine交互。所以只在需要大量计算的时候采用独立Isolate。

    GPU Task Runner

    GPU Task Runner被用于执行设备GPU的相关调用。UI Task Runner创建的Layer Tree信息是平台不相关,也就是说Layer Tree提供了绘制所需要的信息,具体如何实现绘制取决于具体平台和方式,可以是OpenGL,Vulkan,软件绘制或者其他Skia配置的绘图实现。GPU Task Runner中的模块负责将Layer Tree提供的信息转化为实际的GPU指令。GPU Task Runner同时也负责配置管理每一帧绘制所需要的GPU资源,这包括平台Framebuffer的创建,Surface生命周期管理,保证Texture和Buffers在绘制的时候是可用的。

    基于Layer Tree的处理时长和GPU帧显示到屏幕的耗时,GPU Task Runner可能会延迟下一帧在UI Task Runner的调度。一般来说UI Runner和GPU Runner跑在不同的线程。存在这种可能,UI Runner在已经准备好了下一帧的情况下,GPU Runner却还正在向GPU提交上一帧。这种延迟调度机制确保不让UI Runner分配过多的任务给GPU Runner。

    前面我们提到GPU Runner可以导致UI Runner的帧调度的延迟,GPU Runner的过载会导致Flutter应用的卡顿。一般来说用户没有机会向GPU Runner直接提交任务,因为平台和Dart代码都无法跑进GPU Runner。但是Embeder还是可以向GPU Runner提交任务的。因此建议为每一个Engine实例都新建一个专用的GPU Runner线程。

    IO Task Runner

    前面讨论的几个Runner对于执行任务的类型都有比较强的限制。Platform Runner过载可能导致系统WatchDog强杀,UI和GPU Runner过载则可能导致Flutter应用的卡顿。但是GPU线程有一些必要操作是比较耗时间的,比如IO,而这些操作正是IO Runner需要处理的。

    IO Runner的主要功能是从图片存储(比如磁盘)中读取压缩的图片格式,将图片数据进行处理为GPU Runner的渲染做好准备。在Texture的准备过程中,IO Runner首先要读取压缩的图片二进制数据(比如PNG,JPEG),将其解压转换成GPU能够处理的格式然后将数据上传到GPU。这些复杂操作如果跑在GPU线程的话会导致Flutter应用UI卡顿。但是只有GPU Runner能够访问GPU,所以IO Runner模块在引擎启动的时候配置了一个特殊的Context,这个Context跟GPU Runner使用的Context在同一个ShareGroup。事实上图片数据的读取和解压是可以放到一个线程池里面去做的,但是这个Context的访问只能在特定线程才能保证安全。这也是为什么需要有一个专门的Runner来处理IO任务的原因。获取诸如ui.Image这样的资源只有通过async call,当这个调用发生的时候Flutter Framework告诉IO Runner进行刚刚提到的那些图片异步操作。这样GPU Runner可以使用IO Runner准备好的图片数据而不用进行额外的操作。

    用户操作,无论是Dart Code还是Native Plugins都是没有办法直接访问IO Runner。尽管Embeder可以将一些一般复杂任务调度到IO Runner,这不会直接导致Flutter应用卡顿,但是可能会导致图片和其它一些资源加载的延迟间接影响性能。所以建议为IO Runner创建一个专用的线程。

    各个平台目前默认Runner线程实现

    前面我们提到Engine Runner的线程可以按照实际情况进行配置,各个平台目前有自己的实现策略。

    iOS和Android

    Mobile平台上面每一个Engine实例启动的时候会为UI,GPU,IO Runner各自创建一个新的线程。所有Engine实例共享同一个Platform Runner和线程。

    Fuchsia

    每一个Engine实例都为UI,GPU,IO,Platform Runner创建各自新的线程。

    自定义配置线程可行方案

    我们注意到Mobile平台上面,Platform Runner和Thread是共享的。
    引擎源码如下:

        Shell::Shell(fxl::CommandLine command_line)
        : command_line_(std::move(command_line)) {
      FXL_DCHECK(!g_shell);
    
      gpu_thread_.reset(new fml::Thread("gpu_thread"));
      ui_thread_.reset(new fml::Thread("ui_thread"));
      io_thread_.reset(new fml::Thread("io_thread"));
    
      // Since we are not using fml::Thread, we need to initialize the message loop
      // manually.
      fml::MessageLoop::EnsureInitializedForCurrentThread();
    
      blink::Threads threads(fml::MessageLoop::GetCurrent().GetTaskRunner(),
                             gpu_thread_->GetTaskRunner(),
                             ui_thread_->GetTaskRunner(),
                             io_thread_->GetTaskRunner());
      blink::Threads::Set(threads);
    
      blink::Threads::Gpu()->PostTask([this]() { InitGpuThread(); });
      blink::Threads::UI()->PostTask([this]() { InitUIThread(); });
    
      blink::SetRegisterNativeServiceProtocolExtensionHook(
          PlatformViewServiceProtocol::RegisterHook);
    }

    这里我们可以进行改动,让引擎每个实例初始化独自的线程:

    
        gpu_thread_.reset(new fml::Thread("gpu_thread"));
        ui_thread_.reset(new fml::Thread("ui_thread"));
        io_thread_.reset(new fml::Thread("io_thread"));
    
        platform_thread_.reset(new fml::Thread("platform_thread"));
    
        blink::Threads threads(platform_thread_->GetTaskRunner(),
                                gpu_thread_->GetTaskRunner(),
                                ui_thread_->GetTaskRunner(),
                                io_thread_->GetTaskRunner());
    

    理论上你可以配置任意线程供其使用,不过最好遵循最佳实践。

    具体代码导读

    iOS Android平台可以参考Flutter Engine源码:

    flutter/common/threads.cc
    flutter/shell/common/shell.cc

    Dart isolate机制

    An isolated Dart execution context. 这是文档对isolate的定义。
    

    isolate定义

    isolate是Dart对actor并发模式的实现。运行中的Dart程序由一个或多个actor组成,这些actor也就是Dart概念里面的isolate。isolate是有自己的内存和单线程控制的运行实体。isolate本身的意思是“隔离”,因为isolate之间的内存在逻辑上是隔离的。isolate中的代码是按顺序执行的,任何Dart程序的并发都是运行多个isolate的结果。因为Dart没有共享内存的并发,没有竞争的可能性所以不需要锁,也就不用担心死锁的问题。

    isolate之间的通信

    由于isolate之间没有共享内存,所以他们之间的通信唯一方式只能是通过Port进行,而且Dart中的消息传递总是异步的。

    isolate与普通线程的区别

    我们可以看到isolate神似Thread,但实际上两者有本质的区别。操作系统内内的线程之间是可以有共享内存的而isolate没有,这是最为关键的区别。

    isolate实现简述

    我们可以阅读Dart源码里面的isolate.cc文件看看isolate的具体实现。
    我们可以看到在isolate创建的时候有以下几个主要步骤:

    • 初始化isolate数据结构
    • 初始化堆内存(Heap)
    • 进入新创建的isolate,使用跟isolate一对一的线程运行isolate
    • 配置Port
    • 配置消息处理机制(Message Handler)
    • 配置Debugger,如果有必要的话
    • 将isolate注册到全局监控器(Monitor)

    我们看看isolate开始运行的主要代码

    
    Thread* Isolate::ScheduleThread(bool is_mutator, bool bypass_safepoint) {
      // Schedule the thread into the isolate by associating
      // a 'Thread' structure with it (this is done while we are holding
      // the thread registry lock).
      Thread* thread = NULL;
      OSThread* os_thread = OSThread::Current();
      if (os_thread != NULL) {
    
        MonitorLocker ml(threads_lock(), false);
    
        // Check to make sure we don't already have a mutator thread.
        if (is_mutator && scheduled_mutator_thread_ != NULL) {
          return NULL;
        }
    
       
        while (!bypass_safepoint && safepoint_handler()->SafepointInProgress()) {
          ml.Wait();
        }
    
        // Now get a free Thread structure.
        thread = thread_registry()->GetFreeThreadLocked(this, is_mutator);
        ASSERT(thread != NULL);
    
        // Set up other values and set the TLS value.
        thread->isolate_ = this;
        ASSERT(heap() != NULL);
        thread->heap_ = heap();
        thread->set_os_thread(os_thread);
        ASSERT(thread->execution_state() == Thread::kThreadInNative);
        thread->set_execution_state(Thread::kThreadInVM);
        thread->set_safepoint_state(0);
        thread->set_vm_tag(VMTag::kVMTagId);
        ASSERT(thread->no_safepoint_scope_depth() == 0);
        os_thread->set_thread(thread);
        if (is_mutator) {
          scheduled_mutator_thread_ = thread;
          if (this != Dart::vm_isolate()) {
            scheduled_mutator_thread_->set_top(heap()->new_space()->top());
            scheduled_mutator_thread_->set_end(heap()->new_space()->end());
          }
        }
        Thread::SetCurrent(thread);
        os_thread->EnableThreadInterrupts();
    
        thread->ResetHighWatermark();
      }
      return thread;
    }

    我们可以看到Dart本身抽象了isolate和thread,实际上底层还是使用操作系统的提供的OSThread。

    (Isolate) -> (Dart Thread) -> (OS Thread)

    Flutter Engine Runners与Dart Isolate

    有朋友看到这里可能会问既然Flutter Engine有自己的Runner,那为何还要Dart的Isolate呢,他们之间又是什么关系呢?

    那我们还要从Runner具体的实现说起,Runner是一个抽象概念,我们可以往Runner里面提交任务,任务被Runner放到它所在的线程去执行,这跟iOS GCD的执行队列很像。我们查看iOS Runner的实现实际上里面是一个loop,这个loop就是CFRunloop,在iOS平台上Runner具体实现就是CFRunloop。被提交的任务被放到CFRunloop去执行。

    Dart的Isolate是Dart虚拟机自己管理的,Flutter Engine无法直接访问。Root Isolate通过Dart的C++调用能力把UI渲染相关的任务提交到UI Runner执行这样就可以跟Flutter Engine相关模块进行交互,Flutter UI相关的任务也被提交到UI Runner也可以相应的给Isolate一些事件通知,UI Runner同时也处理来自App方面Native Plugin的任务。

    所以简单来说Dart isolate跟Flutter Runner是相互独立的,他们通过任务调度机制相互协作。

    踩坑血泪史

    理解Flutter Engine的原理以及Dart虚拟机的异步实现,让我们避免采坑,更加灵活高效地进行开发。
    在项目应用过程我们踩过不少坑在采坑和填坑的过程中不断学习。这里我简单聊其中一个具体的案例:当时我们需要把Native加载好图片数据注册到Engine里面去以便生成Texture渲染,使用完资源我们需要将其移除,看起来非常清晰的逻辑竟然造成了野指针问题。后来排查到注册的时候在一个子线程进行而移除却在Platform线程进行,在弄清楚线程结构以后问题也就迎刃而解。

    结语

    本文我们主要讨论了Flutter层面的线程配置管理以及Dart本身isolate的实现。在深入了解Flutter线程机制以后,我们在开发过程当中更加得心应手,同时也启发我们如何去设计类似应用内的线程结构。
    目前我们在探索单个Flutter Engine以组件的方式启动,也就是多个Flutter Engine实例同时存在通过Port来进行通信的可能方案。感兴趣或者有相关经验的朋友欢迎交流,还请不吝赐教。

    简历投递:guicai.gxy@alibaba-inc.com

    参考资料

    展开全文
  • Dart Isolate通信

    2019-12-11 14:05:30
    参考文章: https://alvinalexander.com/dart/dart-isolates-example
    展开全文
  • 本文由闲鱼技术团队福居撰写,结合Flutter Engine官方文档讨论了Flutter Engine内的线程管理模式以及Dart Isolate机制,希望与大家一起探讨。 在终端业务需求日益复杂,版本迭代日趋于频繁的情况下,我们迫切需要...
  • Flutter是一款开源的移动跨...聊一聊Flutter Engine线程管理与Dart Isolate机制 作者:技术小能手 阿里150亿战略入股分众, 广告业的新零售时刻来临 作者:技术小能手 “知天命”的英特尔,过去有些遗憾未来有些...
  • Dart - Isolate 并发

    千次阅读 2018-04-21 10:00:01
    Dart中实现并发可以用Isolate,它是类似于线程(thread)但不共享内存的独立运行的worker,是一个独立的Dart程序执行环境。其实默认环境就是一个main isolate。 在Dart语言中,所有的Dart代码都运行在某个isolate中...
  • Dart中的Isolate

    2021-05-16 00:18:50
    Isolate中文意思是隔离,是 Dart 中的线程。在 Dart 中 async 和 Future 无法解决所有耗时的工作。 Isolate虽好,但也有合适的使用场景,不建议滥用Isolate,每当我们创建出来一个新的 Isolate 至少需要 2mb 左右的...
  • Dart基础之Isolate

    2021-05-12 19:10:00
    Dart基础之Isolate 背景 在其他语言中为了高效利用多核CPU,通常使用多线程并行来实现并发执行代码,通过共享数据来保证多线程之间的协同,但这种模式衍生出了很多问题,开辟线程带来资源消耗,数据共享代理死锁问题...
  • dart2 web端不再支持对 isolate 的支持。 对于javascript玩家推荐使用 Web Workers 替换。API不支持多端统一这让人太不爽了,如果你有什么方法解决,求评论告知,万分感谢! 不再支持的原因: 原论坛链接:...
  • Dart语言中的Isolate

    2021-05-07 16:26:07
    概述 Dart本身是Google推出...还有JavaScript的单线程模型,只能依赖JS解释引擎的异步任务执行机制,开发者没有办法自己启动新的线程去执行耗时代码,但是Dart却提供了这个能力 — IsolateIsolate是一种特殊的线程,
  •    使用Isolate的并发编程:... import 'dart:isolate'; 复制代码  该Library主要包含下面几个类: Isolate:Dart执行上下文的隔离区。 ReceivePort:与SendPort一起,是隔离区之间唯一的通信方式。 SendPort:将消...
  • Dart 在单线程中是以消息循环机制来运行的,其中包含两个任务队列,一个是“微任务队列” microtask queue,另一个叫做“事件队列” event queue。从图中可以发现,微任务队列的执行优先级高于事件队列。 现在我们...
  • Flutter开发指南之理论篇:Dart语法05(单线程模型,事件循环模型,Isolate)  Dart是一门面向对象语言,它针对web 和移动设备开发进行了优化,主要特点为: 一切皆对象!无论是数字,函数还是null
  • 它是Dart Isolate (在Flutter和Dart VM上)周围的薄包装,使它们更易于使用。 演员 要启动一个演员很容易。 您只需创建一个Handler实现在Actor的隔离中处理消息的逻辑,然后使用它来创建Actor : class Two with ...
  • dart 07.1Dart执行模型

    2020-06-19 18:52:45
    Dart 是一种单线程语言 首先我们需要记住 ​ Dart 是单线程的并且Flutter依赖于Dart 重点 Dart 同一时刻只执行一个...当启动一个Flutter/Dart 程序时 将创建启动一个新的线程或者进程Dart中叫Isolate这个Iolate 将作
  • isolate 通信

    2019-05-06 21:50:00
    main.dart import 'package:flutter/material.dart';...import 'package:flutter_isolate/flutter_isolate.dart'; import 'isolates.dart'; import 'dbhelper.dart'; import 'package:rxdart/rxdart.dart'...

空空如也

空空如也

1 2 3 4 5 ... 11
收藏数 219
精华内容 87
关键字:

dartisolate