闲鱼技术-福居

  1. 本文结合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线程管理与Dart Isolate机制 - 图1

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是共享的。
引擎源码如下：

  1.     Shell::Shell(fxl::CommandLine command_line)
  2.     : command_line_(std::move(command_line)) {
  3.   FXL_DCHECK(!g_shell);
  5.   gpu_thread_.reset(new fml::Thread("gpu_thread"));
  6.   ui_thread_.reset(new fml::Thread("ui_thread"));
  7.   io_thread_.reset(new fml::Thread("io_thread"));
  9.   // Since we are not using fml::Thread, we need to initialize the message loop
  10.   // manually.
  11.   fml::MessageLoop::EnsureInitializedForCurrentThread();
  13.   blink::Threads threads(fml::MessageLoop::GetCurrent().GetTaskRunner(),
  14.                          gpu_thread_->GetTaskRunner(),
  15.                          ui_thread_->GetTaskRunner(),
  16.                          io_thread_->GetTaskRunner());
  17.   blink::Threads::Set(threads);
  19.   blink::Threads::Gpu()->PostTask([this]() { InitGpuThread(); });
  20.   blink::Threads::UI()->PostTask([this]() { InitUIThread(); });
  22.   blink::SetRegisterNativeServiceProtocolExtensionHook(
  23.       PlatformViewServiceProtocol::RegisterHook);
  24. }

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

  2.     gpu_thread_.reset(new fml::Thread("gpu_thread"));
  3.     ui_thread_.reset(new fml::Thread("ui_thread"));
  4.     io_thread_.reset(new fml::Thread("io_thread"));
  6.     platform_thread_.reset(new fml::Thread("platform_thread"));
  8.     blink::Threads threads(platform_thread_->GetTaskRunner(),
  9.                             gpu_thread_->GetTaskRunner(),
  10.                             ui_thread_->GetTaskRunner(),
  11.                             io_thread_->GetTaskRunner());

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

具体代码导读

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

  1. flutter/common/threads.cc
  2. flutter/shell/common/shell.cc

Dart isolate机制

  1. 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开始运行的主要代码

  2. Thread* Isolate::ScheduleThread(bool is_mutator, bool bypass_safepoint) {
  3.   // Schedule the thread into the isolate by associating
  4.   // a 'Thread' structure with it (this is done while we are holding
  5.   // the thread registry lock).
  6.   Thread* thread = NULL;
  7.   OSThread* os_thread = OSThread::Current();
  8.   if (os_thread != NULL) {
  10.     MonitorLocker ml(threads_lock(), false);
  12.     // Check to make sure we don't already have a mutator thread.
  13.     if (is_mutator && scheduled_mutator_thread_ != NULL) {
  14.       return NULL;
  15.     }
  18.     while (!bypass_safepoint && safepoint_handler()->SafepointInProgress()) {
  19.       ml.Wait();
  20.     }
  22.     // Now get a free Thread structure.
  23.     thread = thread_registry()->GetFreeThreadLocked(this, is_mutator);
  24.     ASSERT(thread != NULL);
  26.     // Set up other values and set the TLS value.
  27.     thread->isolate_ = this;
  28.     ASSERT(heap() != NULL);
  29.     thread->heap_ = heap();
  30.     thread->set_os_thread(os_thread);
  31.     ASSERT(thread->execution_state() == Thread::kThreadInNative);
  32.     thread->set_execution_state(Thread::kThreadInVM);
  33.     thread->set_safepoint_state(0);
  34.     thread->set_vm_tag(VMTag::kVMTagId);
  35.     ASSERT(thread->no_safepoint_scope_depth() == 0);
  36.     os_thread->set_thread(thread);
  37.     if (is_mutator) {
  38.       scheduled_mutator_thread_ = thread;
  39.       if (this != Dart::vm_isolate()) {
  40.         scheduled_mutator_thread_->set_top(heap()->new_space()->top());
  41.         scheduled_mutator_thread_->set_end(heap()->new_space()->end());
  42.       }
  43.     }
  44.     Thread::SetCurrent(thread);
  45.     os_thread->EnableThreadInterrupts();
  47.     thread->ResetHighWatermark();
  48.   }
  49.   return thread;
  50. }

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

Flutter Engine线程管理与Dart Isolate机制 - 图2

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

参考资料