Flutter - 深入理解Dart虚拟机启动

基于Flutter 1.5，从源码视角来深入剖析引擎启动中的Dart虚拟机启动流程，相关源码目录见文末附录

一、概述

1.1 Dart虚拟机概述

Dart虚拟机拥有自己的Isolate，完全由虚拟机自己管理的，Flutter引擎也无法直接访问。Dart的UI相关操作，是由Root Isolate通过Dart的C++调用，或者是发送消息通知的方式，将UI渲染相关的任务提交到UIRunner执行，这样就可以跟Flutter引擎相关模块进行交互。

Isolate之间内存并不共享，而是通过Port方式通信，每个Isolate是有自己的内存以及相应的线程载体。从字面上理解，Isolate是“隔离”，isolate之间的内是逻辑隔离的。Isolate中的代码也是按顺序执行，因为Dart没有共享内存的并发，没有竞争的可能性，故不需要加锁，也没有死锁风险。对于Dart程序的并发则需要依赖多个isolate来实现。

1.2 Dart虚拟机启动工作

文章在介绍flutter引擎启动过程，有两个环节没有展开讲解，那就是DartVM和Isolate的创建过程。Dart与Isolate的启动过程是在FlutterActivity的onCreate()过程触发，在引擎启动的过程有3个环节会跟Dart与Isolate的启动相关，如下所示：

• AndroidShellHolder对象的创建过程，会执行Shell::Create()方法，这里会调用DartVMRef::Create()，[见小节2.1]
• Shell::Create()方法完成，然后创建完Shell完成对象，再接着Engine对象的创建过程，先创建RuntimeController对象，这里会调用DartIsolate::CreateRootIsolate()，[见小节3.1]
• AndroidShellHolder创建完成后，回调FlutterActivityDelegate的runBundle()过程，经过层层调用，会调用到DartIsolate::Run()，[见小节4.1]

1.2.1 DartVM启动工作

AndroidShellHolder对象的创建过程，会调用到DartVMRef::Create()，进行DartVM创建，主要是为Dart虚拟机解析数据DartVMData，注册一系列Native方法，创建名专属vm的Isolate对象，初始化虚拟机内存、堆、线程、StoreBuffer等大量对象，工作内容如下：

1. 同一个进程只有一个Dart虚拟机，所有的Shell共享该进程中的Dart虚拟机，当leak_vm为false则在最后一个Shell对象退出时会回收dart虚拟机， 当leak_vm为true则即便Shell对象全部退出也不会回收dart虚拟机，这是为了优化再次启动的速度；

2. 创建的IsolateNameServer对象，里面有一个重要的成员port_mapping_，以端口名为key，端口号为value的map结构，记录所有注册的port端口； 可通过RegisterIsolatePortWithName()注册Isolate端口，通过LookupIsolatePortByName()根据端口名来查询端口号;

3. 创建DartVMData对象，从settings中解析出vm_snapshot,isolate_snapshot这两个DartSnapshot对象，DartSnapshot里有data_和instructions_两个字段；

4. 创建ListeningSocketRegistry对象，其中有两个重要的成员变量sockets_by_port_（记录以端口号为key的socket集合），sockets_by_fd_（记录以fd为key的socket集合）；

5. 通过pthread_create创建名为”dart:io EventHandler”的线程，然后进入该线程进入poll轮询方法，一旦收到事件则执行HandleEvents()

6. 执行DartUI::InitForGlobal()：执行相关对象的RegisterNatives()注册Native方法，用于Dart代码调用C++代码。

   • 创建DartLibraryNatives类型的g_natives对象，作为静态变量，其成员变量entries_和symbols_分别用于记录NativeFunction和Symbol信息；通过该对象的Register()，注册dart的native方法，用于Dart调用C++代码；通过GetNativeFunction(),GetSymbol()来查询Native方法和符号信息。
   • Canvas、DartRuntimeHooks、Paragraph、Scene、Window等大量对象都会依次执行RegisterNatives(g_natives)来注册各种Native方法，

7. 执行Dart::Init()：传递的参数params记录isolate和文件等相关callback，用于各种对象的初始化

   • 初始化VirtualMemory、OSThread、PortMap、FreeListElement、ForwardingCorpse、Api、NativeSymbolResolver、SemiSpace、StoreBuffer、MarkingStack对象

   • 初始化ThreadPool线程池对象

   • 创建名为”vm-isolate”的Isolate对象，注意此处不允许混淆符号，将新创建的isolate添加到isolates_list_head_链表；

   • 为该isolate创建Heap、ApiState等对象；

   • 创建IsolateMessageHandler，其继承于MessageHandler，MessageHandler中有两个比较重要的成员变量queue_和oob_queue_，用于记录普通消息和oob消息的队列。

   • isolate需要有一个Port端口号，通过PortMap::CreatePort()随机数生成一个整型的端口号，PortMap的成员变量map_是一个记录端口entry的HashMap，每一个entry里面有端口号，handler，以及端口状态。

DartVM创建流程

1.2.2 Isolate启动工作

Dart虚拟机创建完成后，需要创建Engine对象，然后调用DartIsolate::CreateRootIsolate()来创建Isolate。每个Engine对应需要一个Isolate对象。

1. 创建DartIsolate和UIDartState对象，该对象继承于UIDartState对象；
2. 创建Root Isolate，并初始化Isolate相关信息，这个跟前面的Isolate过程一致。
   • 创建名为“Isolate-xxx”的Isolate对象，其中xxx是通过PortMap::CreatePort所创建port端口号
3. 只有root isolates能和window交互，也只有Root Isolate才会执行DartMessageHandler::Initialize()，设置task_dispatcher_等价于UITaskRunner->PostTask()；
4. DartRuntimeHooks安装过程，包括dart:isolate，dart:_internal，dart:core，dart:async，dart:io，

RootIsolate创建流程

1.3 说明

1.3.1 如何注册Native方法

DartUI::InitForGlobal()这个过程再细看看

1.3.2 Isolate说明

关于Isolate有以下四种：

• 虚拟机Isolate：”vm-isolate”，运行在ui线程
• 常见Isolate：“Isolate-xxx”，对于RootIsolate则属于这个类别，运行在ui线程；
• 虚拟机服务Isolate：”vm-service”，运行在独立的线程；
• 内核服务Isolate：”kernel-service”；

另外，Runtime Mode运行时模式有3种：debug，profile，release，其中debug模式使用JIT，profile/release使用AOT。在整个源码过程会有不少通过宏来控制针对不同运行模式的代码。 比如当处于非预编译模式(DART_PRECOMPILED_RUNTIME)，则开启Assert断言，否则关闭断言。

1.3.3 相关类图

Isolate类图

1.3.4 核心代码入口

文章在介绍flutter引擎启动过程，有两个环节没有展开讲解，那就是DartVM和Isolate的创建过程。Dart与Isolate的启动过程是在FlutterActivity的onCreate()过程触发，在引擎启动的过程有3个环节会跟Dart与Isolate的启动相关，如下所示：

• AndroidShellHolder对象的创建过程，会执行Shell::Create()方法，这里会调用DartVMRef::Create()，[见小节2.1]
• Shell::Create()方法完成，然后创建完Shell完成对象，再接着Engine对象的创建过程，先创建RuntimeController对象，这里会调用DartIsolate::CreateRootIsolate()，[见小节3.1]
• AndroidShellHolder创建完成后，回调FlutterActivityDelegate的runBundle()过程，经过层层调用，会调用到DartIsolate::Run()，[见小节4.1]

1//创建Dart虚拟机
2new AndroidShellHolder
3  Shell::Create()
4    DartVMRef::Create()
5
6//创建Isolate
7new Engine
8  new RuntimeController
9    DartIsolate::CreateRootIsolate
10
11AndroidShellHolder::Launch
12    Engine::Run
13      Engine::PrepareAndLaunchIsolate
14        DartIsolate::Run 

接下来依次看看上述这3个过程。

二、创建Dart虚拟机

2.1 DartVMRef::Create

[-> flutter/runtime/dart_vm_lifecycle.cc]

1static std::weak_ptr<DartVM> gVM;
2static std::shared_ptr<DartVM>* gVMLeak;
3
4DartVMRef DartVMRef::Create(Settings settings,
5                            fml::RefPtr<DartSnapshot> vm_snapshot,
6                            fml::RefPtr<DartSnapshot> isolate_snapshot,
7                            fml::RefPtr<DartSnapshot> shared_snapshot) {
8  std::lock_guard<std::mutex> lifecycle_lock(gVMMutex);
9
10  //当该进程存在一个正在运行虚拟机，则获取其强引用，复用该虚拟机
11  if (auto vm = gVM.lock()) {
12    return DartVMRef{std::move(vm)};
13  }
14
15  std::lock_guard<std::mutex> dependents_lock(gVMDependentsMutex);
16  ...
17  //创建isolate服务
18  auto isolate_name_server = std::make_shared<IsolateNameServer>();
19  //创建虚拟机[见小节2.2]
20  auto vm = DartVM::Create(std::move(settings),          
21                           std::move(vm_snapshot),       
22                           std::move(isolate_snapshot),  
23                           std::move(shared_snapshot),   
24                           isolate_name_server           
25  );
26  ...
27  gVMData = vm->GetVMData();
28  gVMServiceProtocol = vm->GetServiceProtocol();
29  gVMIsolateNameServer = isolate_name_server;
30  gVM = vm;
31  //用于优化第二次的启动速度
32  if (settings.leak_vm) {
33    gVMLeak = new std::shared_ptr<DartVM>(vm);
34  }
35
36  return DartVMRef{std::move(vm)};
37} 

同一个进程只有一个Dart虚拟机，所有的Shell共享该进程中的Dart虚拟机，当leak_vm为false则在最后一个Shell对象退出时会回收dart虚拟机，当leak_vm为true则即便Shell对象全部退出也不会回收dart虚拟机，这是为了优化再次启动的速度。

这里创建的IsolateNameServer里面有一个重要的成员port_mapping_，以端口名为key，端口号为value的map结构，记录所有注册的port端口。

2.2 DartVM::Create

[-> flutter/runtime/dart_vm.cc]

1std::shared_ptr<DartVM> DartVM::Create(
2    Settings settings,
3    fml::RefPtr<DartSnapshot> vm_snapshot,
4    fml::RefPtr<DartSnapshot> isolate_snapshot,
5    fml::RefPtr<DartSnapshot> shared_snapshot,
6    std::shared_ptr<IsolateNameServer> isolate_name_server) {
7  //只有settings有初值，其余参数为空[见小节2.2.1]
8  auto vm_data = DartVMData::Create(settings,                     //
9                                    std::move(vm_snapshot),       //
10                                    std::move(isolate_snapshot),  //
11                                    std::move(shared_snapshot)    //
12  );
13  ...
14  //[见小节2.3]
15  return std::shared_ptr<DartVM>(
16      new DartVM(std::move(vm_data), std::move(isolate_name_server)));
17} 

2.2.1 DartVMData::Create

[-> flutter/runtime/dart_vm_data.cc]

1std::shared_ptr<const DartVMData> DartVMData::Create(
2    Settings settings,
3    fml::RefPtr<DartSnapshot> vm_snapshot,
4    fml::RefPtr<DartSnapshot> isolate_snapshot,
5    fml::RefPtr<DartSnapshot> shared_snapshot) {
6  if (!vm_snapshot || !vm_snapshot->IsValid()) {
7    vm_snapshot = DartSnapshot::VMSnapshotFromSettings(settings);
8    ...
9  }
10
11  if (!isolate_snapshot || !isolate_snapshot->IsValid()) {
12    isolate_snapshot = DartSnapshot::IsolateSnapshotFromSettings(settings);
13    ...
14  }
15
16  if (!shared_snapshot || !shared_snapshot->IsValid()) {
17    shared_snapshot = DartSnapshot::Empty();
18    ...
19  }
20  //[见小节2.2.2]
21  return std::shared_ptr<const DartVMData>(new DartVMData(
22      std::move(settings),          //
23      std::move(vm_snapshot),       //
24      std::move(isolate_snapshot),  //
25      std::move(shared_snapshot)    //
26      ));
27} 

从settings中解析出vm_snapshot,isolate_snapshot数据。

2.2.2 DartVMData初始化

[-> flutter/runtime/dart_vm_data.cc]

1DartVMData::DartVMData(Settings settings,
2                       fml::RefPtr<const DartSnapshot> vm_snapshot,
3                       fml::RefPtr<const DartSnapshot> isolate_snapshot,
4                       fml::RefPtr<const DartSnapshot> shared_snapshot)
5    : settings_(settings),
6      vm_snapshot_(vm_snapshot),
7      isolate_snapshot_(isolate_snapshot),
8      shared_snapshot_(shared_snapshot) {} 

2.3 DartVM初始化

[-> flutter/runtime/dart_vm.cc]

1DartVM::DartVM(std::shared_ptr<const DartVMData> vm_data,
2               std::shared_ptr<IsolateNameServer> isolate_name_server)
3    : settings_(vm_data->GetSettings()),
4      vm_data_(vm_data),
5      isolate_name_server_(std::move(isolate_name_server)),
6      //创建ServiceProtocol
7      service_protocol_(std::make_shared<ServiceProtocol>()) {
8  TRACE_EVENT0("flutter", "DartVMInitializer");
9  gVMLaunchCount++;
10  {
11    TRACE_EVENT0("flutter", "dart::bin::BootstrapDartIo");
12    //[见小节2.4]
13    dart::bin::BootstrapDartIo();
14    if (!settings_.temp_directory_path.empty()) {
15      dart::bin::SetSystemTempDirectory(settings_.temp_directory_path.c_str());
16    }
17  }
18
19  std::vector<const char*> args;
20  args.push_back("--ignore-unrecognized-flags"); //忽略无法识别的flags参数
21
22  for (auto* const profiler_flag : ProfilingFlags(settings_.enable_dart_profiling)) {
23    args.push_back(profiler_flag);
24  }
25  PushBackAll(&args, kDartLanguageArgs, arraysize(kDartLanguageArgs));
26
27  if (IsRunningPrecompiledCode()) {
28    PushBackAll(&args, kDartPrecompilationArgs, arraysize(kDartPrecompilationArgs));
29  }
30
31  bool enable_asserts = !settings_.disable_dart_asserts;
32  if (IsRunningPrecompiledCode()) {
33    enable_asserts = false; //当为预编译模式，则关闭Dart断言
34  }
35
36  if (enable_asserts) {
37    PushBackAll(&args, kDartAssertArgs, arraysize(kDartAssertArgs));
38  }
39
40  if (settings_.start_paused) {
41    PushBackAll(&args, kDartStartPausedArgs, arraysize(kDartStartPausedArgs));
42  }
43
44  if (settings_.disable_service_auth_codes) {
45    PushBackAll(&args, kDartDisableServiceAuthCodesArgs,
46                arraysize(kDartDisableServiceAuthCodesArgs));
47  }
48
49  if (settings_.endless_trace_buffer || settings_.trace_startup) {
50    //开启无限大小的buffer，保证信息不被丢失
51    PushBackAll(&args, kDartEndlessTraceBufferArgs,
52                arraysize(kDartEndlessTraceBufferArgs));
53  }
54
55  if (settings_.trace_systrace) {
56    PushBackAll(&args, kDartSystraceTraceBufferArgs,
57                arraysize(kDartSystraceTraceBufferArgs));
58    PushBackAll(&args, kDartTraceStreamsArgs, arraysize(kDartTraceStreamsArgs));
59  }
60
61  if (settings_.trace_startup) {
62    PushBackAll(&args, kDartTraceStartupArgs, arraysize(kDartTraceStartupArgs));
63  }
64
65  for (size_t i = 0; i < settings_.dart_flags.size(); i++)
66    args.push_back(settings_.dart_flags[i].c_str());
67
68  char* flags_error = Dart_SetVMFlags(args.size(), args.data());
69  ...
70
71  DartUI::InitForGlobal();  //[见小节2.8]
72
73  {
74    TRACE_EVENT0("flutter", "Dart_Initialize");
75    Dart_InitializeParams params = {};
76    params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
77    params.vm_snapshot_data = vm_data_->GetVMSnapshot().GetData()->GetSnapshotPointer();
78    params.vm_snapshot_instructions = vm_data_->GetVMSnapshot().GetInstructionsIfPresent();
79    params.create = reinterpret_cast<decltype(params.create)>(
80                  DartIsolate::DartIsolateCreateCallback);
81    params.shutdown = reinterpret_cast<decltype(params.shutdown)>(
82                  DartIsolate::DartIsolateShutdownCallback);
83    params.cleanup = reinterpret_cast<decltype(params.cleanup)>(
84                  DartIsolate::DartIsolateCleanupCallback);
85    params.thread_exit = ThreadExitCallback;
86    params.get_service_assets = GetVMServiceAssetsArchiveCallback;
87    params.entropy_source = dart::bin::GetEntropy;
88    //[见小节2.9]
89    char* init_error = Dart_Initialize(&params);
90
91    //应用生命周期中最早的可记录时间戳发送到timeline
92    if (engine_main_enter_ts != 0) {
93      Dart_TimelineEvent("FlutterEngineMainEnter",
94                         engine_main_enter_ts, engine_main_enter_ts,     
95                         Dart_Timeline_Event_Duration, 0, nullptr, nullptr                        
96      );
97    }
98  }
99
100  Dart_SetFileModifiedCallback(&DartFileModifiedCallback);
101
102  //允许Dart vm输出端stdout和stderr
103  Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
104                                 &ServiceStreamCancelCallback);
105
106  Dart_SetEmbedderInformationCallback(&EmbedderInformationCallback);
107
108  if (settings_.dart_library_sources_kernel != nullptr) {
109    std::unique_ptr<fml::Mapping> dart_library_sources =
110        settings_.dart_library_sources_kernel();
111    //设置dart：*库的源代码以进行调试。
112    Dart_SetDartLibrarySourcesKernel(dart_library_sources->GetMapping(),
113                                     dart_library_sources->GetSize());
114  }
115} 

该方法主要功能：

• 根据条件，创建Dart所需要的args信息
• 是否开启assert断言，取决于是否运行预编译代码。只有在debug模式才以JIT模式编译dart代码，对于profile/release都是以AOT模式编译成机器码；

2.4 BootstrapDartIo

[-> third_party/dart/runtime/bin/dart_io_api_impl.cc]

1void BootstrapDartIo() {
2  TimerUtils::InitOnce();
3  //[见小节2.5]
4  EventHandler::Start();
5} 

2.5 EventHandler::Start

[-> third_party/dart/runtime/bin/eventhandler.cc]

1void EventHandler::Start() {
2  ListeningSocketRegistry::Initialize(); //[见小节2.5.1]
3  shutdown_monitor = new Monitor();   //[见小节2.5.3]
4  event_handler = new EventHandler();  //[见小节2.5.4]
5  event_handler->delegate_.Start(event_handler); //[见小节2.6]
6} 

此处delegate_是EventHandlerImplementation对象。

2.5.1 ListeningSocketRegistry::Initialize

[-> third_party/dart/runtime/bin/socket.cc]

1ListeningSocketRegistry* globalTcpListeningSocketRegistry = NULL;
2
3void ListeningSocketRegistry::Initialize() {
4  //[见小节2.5.2]
5  globalTcpListeningSocketRegistry = new ListeningSocketRegistry();
6} 

初始化全局的socket注册对象，并保存在全局变量globalTcpListeningSocketRegistry中。

2.5.2 ListeningSocketRegistry初始化

[-> third_party/dart/runtime/bin/socket.h]

1class ListeningSocketRegistry {
2  ListeningSocketRegistry()
3      : sockets_by_port_(SameIntptrValue, kInitialSocketsCount),
4        sockets_by_fd_(SameIntptrValue, kInitialSocketsCount),
5        mutex_(new Mutex()) {}
6
7  SimpleHashMap sockets_by_port_;
8  SimpleHashMap sockets_by_fd_;
9  Mutex* mutex_;
10} 

ListeningSocketRegistry有两个重要的成员变量：

• sockets_by_port_：类型为SimpleHashMap，记录以端口号为key的socket集合；
• sockets_by_fd_：类型为SimpleHashMap，记录以fd为key的socket集合；

2.5.3 Monitor初始化

[-> third_party/dart/runtime/bin/thread_android.cc]

1Monitor::Monitor() {
2  pthread_mutexattr_t mutex_attr;
3  pthread_mutexattr_init(&mutex_attr);
4  pthread_mutex_init(data_.mutex(), &mutex_attr);
5  pthread_mutexattr_destroy(&mutex_attr);
6
7  pthread_condattr_t cond_attr;
8  pthread_condattr_init(&cond_attr);
9  pthread_cond_init(data_.cond(), &cond_attr);
10  pthread_condattr_destroy(&cond_attr);
11}
12
13Monitor::~Monitor() {
14  pthread_mutex_destroy(data_.mutex());
15  pthread_cond_destroy(data_.cond());
16} 

此处的data_是Monitor类中的数据类型为MonitorData的私有成员变量，其中mutex()和cond()对应如下两个成员变量：

• mutex_：类型为pthread_mutex_t（互斥锁），用于在多线程中对共享变量的保护
• cond_ ：类型为pthread_cond_t（条件变量），一般和pthread_mutex_t配合使用，以防止有可能对共享变量读写出现非预期行为

对于Monitor有Enter/Exit，以及Wait/Notify/NotifyAll方法，内部的实现便是基于以下方法：

• pthread_mutex_lock: 上锁
• pthread_mutex_unlock：解锁
• pthread_cond_wait：阻塞在条件变量
• pthread_cond_timedwait：带超时机制的阻塞
• pthread_cond_signal：唤醒在条件变量阻塞的线程
• pthread_cond_broadcast：唤醒所有在该条件变量上的线程

2.5.4 EventHandler初始化

[-> third_party/dart/runtime/bin/eventhandler.h]

1class EventHandler {
2  EventHandler() {}
3  //[见小节2.5.5]
4  EventHandlerImplementation delegate_;
5} 

2.5.5 EventHandlerImplementation初始化

[-> third_party/dart/runtime/bin/eventhandler_android.h]

1class EventHandlerImplementation {
2 public:
3  EventHandlerImplementation();
4
5 private:
6  SimpleHashMap socket_map_;
7  TimeoutQueue timeout_queue_;
8  bool shutdown_;
9  int interrupt_fds_[2];
10  int epoll_fd_;
11}; 

2.6 EventHandlerImplementation::Start

[-> third_party/dart/runtime/bin/eventhandler_android.cc]

1void EventHandlerImplementation::Start(EventHandler* handler) {
2  //[见小节2.7]
3  int result = Thread::Start("dart:io EventHandler",
4          &EventHandlerImplementation::Poll, reinterpret_cast<uword>(handler));
5} 

通过Thread::Start()来创建一个名为“dart:io EventHandler”的线程，过程如下所示。

2.6.1 Thread::Start

[-> third_party/dart/runtime/bin/thread_android.cc]

1int Thread::Start(const char* name,
2                  ThreadStartFunction function,
3                  uword parameter) {
4  pthread_attr_t attr;
5  int result = pthread_attr_init(&attr);
6  result = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
7  result = pthread_attr_setstacksize(&attr, Thread::GetMaxStackSize());
8
9  ThreadStartData* data = new ThreadStartData(name, function, parameter);
10  pthread_t tid;
11  //通过pthread_create创建线程，然后触发执行Poll，见[小节2.7]
12  result = pthread_create(&tid, &attr, ThreadStart, data);
13  result = pthread_attr_destroy(&attr);
14  return 0;
15} 

通过pthread_create创建线程，然后在线程中执行function，此处等于EventHandlerImplementation对象中的Poll(EventHandler)方法。

2.7 Poll

[-> third_party/dart/runtime/bin/eventhandler_android.cc]

1void EventHandlerImplementation::Poll(uword args) {
2  ThreadSignalBlocker signal_blocker(SIGPROF);
3  static const intptr_t kMaxEvents = 16;  //最多处理16个事件
4  struct epoll_event events[kMaxEvents];
5  EventHandler* handler = reinterpret_cast<EventHandler*>(args);
6  EventHandlerImplementation* handler_impl = &handler->delegate_;
7
8  while (!handler_impl->shutdown_) {
9    int64_t millis = handler_impl->GetTimeout();
10    intptr_t result = TEMP_FAILURE_RETRY_NO_SIGNAL_BLOCKER(
11        //进入epoll的状态等待事件
12        epoll_wait(handler_impl->epoll_fd_, events, kMaxEvents, millis));
13    if (result != -1) {
14      handler_impl->HandleTimeout(); //[见小节2.7.1]
15      handler_impl->HandleEvents(events, result); //[见小节2.7.2]
16    }
17  }
18  handler->NotifyShutdownDone(); //[见小节2.7.4]
19} 

一旦收到事件，则执行HandleEvents()方法。

2.7.1 HandleTimeout

[-> third_party/dart/runtime/bin/eventhandler_android.cc]

1void EventHandlerImplementation::HandleTimeout() {
2  if (timeout_queue_.HasTimeout()) {
3    int64_t millis = timeout_queue_.CurrentTimeout() -
4                     TimerUtils::GetCurrentMonotonicMillis();
5    if (millis <= 0) {
6      //当已超时，则向指定端口号发送一个空消息
7      DartUtils::PostNull(timeout_queue_.CurrentPort());
8      timeout_queue_.RemoveCurrent();
9    }
10  }
11} 

2.7.2 HandleEvents

[-> third_party/dart/runtime/bin/eventhandler_android.cc]

1void EventHandlerImplementation::HandleEvents(struct epoll_event* events,
2                                              int size) {
3  bool interrupt_seen = false;
4  for (int i = 0; i < size; i++) {
5    if (events[i].data.ptr == NULL) {
6      interrupt_seen = true;
7    } else {
8      DescriptorInfo* di = reinterpret_cast<DescriptorInfo*>(events[i].data.ptr);
9      const intptr_t old_mask = di->Mask();
10      const intptr_t event_mask = GetPollEvents(events[i].events, di);
11      if ((event_mask & (1 << kErrorEvent)) != 0) {
12        di->NotifyAllDartPorts(event_mask);
13        UpdateEpollInstance(old_mask, di);
14      } else if (event_mask != 0) {
15        Dart_Port port = di->NextNotifyDartPort(event_mask);
16        UpdateEpollInstance(old_mask, di);
17        DartUtils::PostInt32(port, event_mask);
18      }
19    }
20  }
21  if (interrupt_seen) {
22    //执行socket事件后，在处理当前事件之前避免关闭套接字。 [见小节2.7.3]
23    HandleInterruptFd();
24  }
25} 

2.7.3 HandleInterruptFd

[-> third_party/dart/runtime/bin/eventhandler_android.cc]

1void EventHandlerImplementation::HandleInterruptFd() {
2  const intptr_t MAX_MESSAGES = kInterruptMessageSize;
3  InterruptMessage msg[MAX_MESSAGES];
4  //从interrupt_fds_中读取消息
5  ssize_t bytes = TEMP_FAILURE_RETRY_NO_SIGNAL_BLOCKER(
6      read(interrupt_fds_[0], msg, MAX_MESSAGES * kInterruptMessageSize));
7  for (ssize_t i = 0; i < bytes / kInterruptMessageSize; i++) {
8    if (msg[i].id == kTimerId) {
9      //当属于定时器消息，则将该消息加入超时消息队列
10      timeout_queue_.UpdateTimeout(msg[i].dart_port, msg[i].data);
11    } else if (msg[i].id == kShutdownId) {
12      //当属于关闭消息，则会停止轮询poll
13      shutdown_ = true;
14    } else {
15      Socket* socket = reinterpret_cast<Socket*>(msg[i].id);
16      RefCntReleaseScope<Socket> rs(socket);
17
18      DescriptorInfo* di =
19          GetDescriptorInfo(socket->fd(), IS_LISTENING_SOCKET(msg[i].data));
20      if (IS_COMMAND(msg[i].data, kShutdownReadCommand)) {
21        //关闭socket读取
22        VOID_NO_RETRY_EXPECTED(shutdown(di->fd(), SHUT_RD));
23      } else if (IS_COMMAND(msg[i].data, kShutdownWriteCommand)) {
24        //关闭socket写入
25        VOID_NO_RETRY_EXPECTED(shutdown(di->fd(), SHUT_WR));
26      } else if (IS_COMMAND(msg[i].data, kCloseCommand)) {
27        // 关系socket，释放系统资源，并移动到下一个消息
28        ...
29        //向端口发送一个销毁的消息
30        DartUtils::PostInt32(port, 1 << kDestroyedEvent);
31      } else if (IS_COMMAND(msg[i].data, kReturnTokenCommand)) {
32        int count = TOKEN_COUNT(msg[i].data);
33        intptr_t old_mask = di->Mask();
34        di->ReturnTokens(msg[i].dart_port, count);
35        UpdateEpollInstance(old_mask, di);
36      } else if (IS_COMMAND(msg[i].data, kSetEventMaskCommand)) {
37        intptr_t events = msg[i].data & EVENT_MASK;
38        intptr_t old_mask = di->Mask();
39        di->SetPortAndMask(msg[i].dart_port, msg[i].data & EVENT_MASK);
40        UpdateEpollInstance(old_mask, di);
41      } else {
42        UNREACHABLE();
43      }
44    }
45  }
46} 

2.7.4 NotifyShutdownDone

[-> third_party/dart/runtime/bin/eventhandler.cc]

1void EventHandler::NotifyShutdownDone() {
2  MonitorLocker ml(shutdown_monitor);
3  ml.Notify(); //唤醒处于等待状态的shutdown_monitor
4} 

唤醒处于等待状态的shutdown_monitor，然后会清理全局注册的socket，见小节[2.7.5]

2.7.4 Stop

[-> third_party/dart/runtime/bin/eventhandler.cc]

1void EventHandler::Stop() {
2  {
3    MonitorLocker ml(shutdown_monitor);
4    event_handler->delegate_.Shutdown();
5    ml.Wait(Monitor::kNoTimeout);  //无限等待，直到被唤醒
6  }
7
8  // 清理
9  delete event_handler;
10  event_handler = NULL;
11  delete shutdown_monitor;
12  shutdown_monitor = NULL;
13
14  //销毁全局注册的socket
15  ListeningSocketRegistry::Cleanup();
16} 

到此[小节2.4]BootstrapDartIo方法执行完成，再回到[小节2.3]执行InitForGlobal()方法

2.8 DartUI::InitForGlobal

[-> flutter/lib/ui/dart_ui.cc]

1void DartUI::InitForGlobal() {
2   //只初始化一次
3  if (!g_natives) {
4    g_natives = new tonic::DartLibraryNatives(); // [见小节2.8.1]
5    Canvas::RegisterNatives(g_natives);
6    CanvasGradient::RegisterNatives(g_natives);
7    CanvasImage::RegisterNatives(g_natives);
8    CanvasPath::RegisterNatives(g_natives);
9    CanvasPathMeasure::RegisterNatives(g_natives);
10    Codec::RegisterNatives(g_natives);
11    DartRuntimeHooks::RegisterNatives(g_natives);  // [见小节2.8.2]
12    EngineLayer::RegisterNatives(g_natives);
13    FontCollection::RegisterNatives(g_natives);
14    FrameInfo::RegisterNatives(g_natives);
15    ImageFilter::RegisterNatives(g_natives);
16    ImageShader::RegisterNatives(g_natives);
17    IsolateNameServerNatives::RegisterNatives(g_natives);
18    Paragraph::RegisterNatives(g_natives);
19    ParagraphBuilder::RegisterNatives(g_natives);
20    Picture::RegisterNatives(g_natives);
21    PictureRecorder::RegisterNatives(g_natives);
22    Scene::RegisterNatives(g_natives);
23    SceneBuilder::RegisterNatives(g_natives);
24    SceneHost::RegisterNatives(g_natives);
25    SemanticsUpdate::RegisterNatives(g_natives);
26    SemanticsUpdateBuilder::RegisterNatives(g_natives);
27    Vertices::RegisterNatives(g_natives);
28    Window::RegisterNatives(g_natives);
29
30    // 第二个isolates不提供UI相关的APIs
31    g_natives_secondary = new tonic::DartLibraryNatives();
32    DartRuntimeHooks::RegisterNatives(g_natives_secondary);
33    IsolateNameServerNatives::RegisterNatives(g_natives_secondary);
34  }
35} 

先创建DartLibraryNatives类型的g_natives，然后利用该对象来注册各种Native方法，这里以DartRuntimeHooks为例来说明[小节2.8.2]

2.8.1 DartLibraryNatives初始化

[-> third_party/tonic/dart_library_natives.h]

1class DartLibraryNatives {
2 public:
3  DartLibraryNatives();
4  ~DartLibraryNatives();
5
6  struct Entry {
7    const char* symbol;
8    Dart_NativeFunction native_function;
9    int argument_count;
10    bool auto_setup_scope;
11  };
12
13  void Register(std::initializer_list<Entry> entries);
14
15  Dart_NativeFunction GetNativeFunction(Dart_Handle name,
16                                        int argument_count,
17                                        bool* auto_setup_scope);
18  const uint8_t* GetSymbol(Dart_NativeFunction native_function);
19
20 private:
21  std::unordered_map<std::string, Entry> entries_;
22  std::unordered_map<Dart_NativeFunction, const char*> symbols_;
23}; 

来DartLibraryNatives的成员变量entries_和symbols_用于记录NativeFunction和Symbol信息，该类有3个方法：

• Register：注册dart的native方法，用于Dart调用C++代码。
• GetNativeFunction：根据Symbol和参数个数来查找NativeFunction
• GetSymbol：根据NativeFunction来查找Symbol

2.8.2 RegisterNatives

[-> flutter/lib/ui/dart_runtime_hooks.cc]

1void DartRuntimeHooks::RegisterNatives(tonic::DartLibraryNatives* natives) {
2  //[见小节2.8.3/ 2.8.4]
3  natives->Register({BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)});
4} 

2.8.3 Register

[-> third_party/tonic/dart_library_natives.cc]

1void DartLibraryNatives::Register(std::initializer_list<Entry> entries) {
2  for (const Entry& entry : entries) {
3    symbols_.emplace(entry.native_function, entry.symbol);
4    entries_.emplace(entry.symbol, entry);
5  }
6} 

将注册的entry都记录DartLibraryNatives对象的成员变量symbols_和entries_里面。

2.8.4 BUILTIN_NATIVE_LIST

[-> flutter/lib/ui/dart_runtime_hooks.cc]

1#define REGISTER_FUNCTION(name, count) {"" #name, name, count, true},
2#define BUILTIN_NATIVE_LIST(V) 
3  V(Logger_PrintString, 1)     
4  V(SaveCompilationTrace, 0)   
5  V(ScheduleMicrotask, 1)      
6  V(GetCallbackHandle, 1)      
7  V(GetCallbackFromHandle, 1) 

这是一个宏定义，REGISTER_FUNCTION的4个参数代表的如下所示的DartLibraryNatives中的Entry结构体

1struct Entry {
2  const char* symbol;
3  Dart_NativeFunction native_function;
4  int argument_count;
5  bool auto_setup_scope;
6}; 

可知，DartRuntimeHooks中注册了ScheduleMicrotask()等共5个Native方法。也就是说当调用natives.dart带有native标识的方法，最终会调用到dart_runtime_hooks.cc中的ScheduleMicrotask()方法，如下所示的两个相对应的方法。

[-> flutter/lib/ui/natives.dart]

void _scheduleMicrotask(void callback()) native 'ScheduleMicrotask'; 

[-> flutter/lib/ui/dart_runtime_hooks.cc]

1void ScheduleMicrotask(Dart_NativeArguments args) {
2  Dart_Handle closure = Dart_GetNativeArgument(args, 0);
3  UIDartState::Current()->ScheduleMicrotask(closure);
4} 

2.9 Dart_Initialize

[-> third_party/dart/runtime/vm/dart_api_impl.cc]

1DART_EXPORT char* Dart_Initialize(Dart_InitializeParams* params) {
2  ...
3  //[见小节2.10]
4  return Dart::Init(params->vm_snapshot_data, params->vm_snapshot_instructions,
5                    params->create, params->shutdown,
6                    params->cleanup, params->thread_exit,
7                    params->file_open, params->file_read,
8                    params->file_write, params->file_close,
9                    params->entropy_source, params->get_service_assets,
10                    params->start_kernel_isolate);
11} 

2.10 Dart::Init

[-> third_party/dart/runtime/vm/dart.cc]

1char* Dart::Init(const uint8_t* vm_isolate_snapshot,
2                 const uint8_t* instructions_snapshot,
3                 Dart_IsolateCreateCallback create,
4                 Dart_IsolateShutdownCallback shutdown,
5                 Dart_IsolateCleanupCallback cleanup,
6                 Dart_ThreadExitCallback thread_exit,
7                 Dart_FileOpenCallback file_open,
8                 Dart_FileReadCallback file_read,
9                 Dart_FileWriteCallback file_write,
10                 Dart_FileCloseCallback file_close,
11                 Dart_EntropySource entropy_source,
12                 Dart_GetVMServiceAssetsArchive get_service_assets,
13                 bool start_kernel_isolate) {
14  const Snapshot* snapshot = nullptr;
15  if (vm_isolate_snapshot != nullptr) {
16    //创建Snapshot
17    snapshot = Snapshot::SetupFromBuffer(vm_isolate_snapshot);
18  }
19
20  if (snapshot != nullptr) {
21    char* error = SnapshotHeaderReader::InitializeGlobalVMFlagsFromSnapshot(snapshot);
22  }
23  ...
24  FrameLayout::Init();
25  //设置dart的线程退出函数、文件操作函数
26  set_thread_exit_callback(thread_exit);
27  SetFileCallbacks(file_open, file_read, file_write, file_close);
28  set_entropy_source_callback(entropy_source);
29
30  OS::Init();
31  start_time_micros_ = OS::GetCurrentMonotonicMicros();
32  VirtualMemory::Init(); //初始化虚拟内存 见[小节2.10.1]
33  OSThread::Init(); //初始化系统线程 见[小节2.10.2]
34  Isolate::InitVM(); //初始化Isolate 见[小节2.10.3]
35  PortMap::Init(); //初始化PortMap 见[小节2.10.4]
36  FreeListElement::Init();
37  ForwardingCorpse::Init();
38  Api::Init();
39  NativeSymbolResolver::Init();
40  SemiSpace::Init();
41  StoreBuffer::Init();
42  MarkingStack::Init();
43
44  predefined_handles_ = new ReadOnlyHandles(); //创建只读handles
45  //创建VM isolate，完成虚拟机初始化 见[小节2.10.5]
46  thread_pool_ = new ThreadPool();
47  {
48    const bool is_vm_isolate = true;
49    Dart_IsolateFlags api_flags;
50    Isolate::FlagsInitialize(&api_flags);
51    //[见小节2.11]
52    vm_isolate_ = Isolate::InitIsolate("vm-isolate", api_flags, is_vm_isolate);
53
54    Thread* T = Thread::Current();
55    StackZone zone(T);
56    HandleScope handle_scope(T);
57    Object::InitNull(vm_isolate_);
58    ObjectStore::Init(vm_isolate_);
59    TargetCPUFeatures::Init();
60    Object::Init(vm_isolate_);
61    ArgumentsDescriptor::Init();
62    ICData::Init();
63    //根据vm_isolate_snapshot是否为空，以及snapshot的kind类型、编译模式来出现相关流程
64    if (vm_isolate_snapshot != NULL) {
65      ...
66    } else {
67      ...
68    }
69
70    T->InitVMConstants(); //初始化VM isolate常量
71    {
72      Object::FinalizeVMIsolate(vm_isolate_);
73    }
74  }
75  Api::InitHandles();
76  Thread::ExitIsolate();  //取消注册该线程中的VM isolate
77  Isolate::SetCreateCallback(create);
78  Isolate::SetShutdownCallback(shutdown);
79  Isolate::SetCleanupCallback(cleanup);
80  ...
81  return NULL;
82} 

根据vm_isolate_snapshot是否则需要进行相关处理，以下3种情况则会直接返回，不再往下执行：

• 当vm_isolate_snapshot不为空的情况时：
  • 当snapshot类型为kFullAOT，且并非处于预编译模式(DART_PRECOMPILED_RUNTIME);
  • 当snapshot类型为kFull，且处于预编译模式(DART_PRECOMPILED_RUNTIME);
  • 当snapshot类型不是kFullAOT或kFullJIT或kFull；
• 当vm_isolate_snapshot等于空的情况时：
  • 当处于预编译模式(DART_PRECOMPILED_RUNTIME)，预编译模式需要预编译的snapshot；

2.10.1 VirtualMemory::Init

[-> third_party/dart/runtime/vm/virtual_memory_posix.cc]

1void VirtualMemory::Init() {
2  page_size_ = getpagesize(); //获取页大小
3} 

2.10.2 OSThread::Init

[-> third_party/dart/runtime/vm/os_thread.cc]

1void OSThread::Init() {
2  //分配全局OSThread锁
3  if (thread_list_lock_ == NULL) {
4    thread_list_lock_ = new Mutex();
5  }
6
7  //创建线程本地Key
8  if (thread_key_ == kUnsetThreadLocalKey) {
9    thread_key_ = CreateThreadLocal(DeleteThread);
10  }
11
12  //使能虚拟机中的OSThread创建
13  EnableOSThreadCreation();
14
15  //创建一个新的OSThread结构体，并赋予TLS
16  OSThread* os_thread = CreateOSThread();
17  OSThread::SetCurrent(os_thread);
18  os_thread->set_name("Dart_Initialize");
19} 

2.10.3 Isolate::InitVM

[-> third_party/dart/runtime/vm/isolate.cc]

1void Isolate::InitVM() {
2  create_callback_ = NULL;
3  if (isolates_list_monitor_ == NULL) {
4    isolates_list_monitor_ = new Monitor();
5  }
6  EnableIsolateCreation(); //使能Isolate创建
7} 

2.10.4 PortMap::Init

[-> third_party/dart/runtime/vm/port.cc]

1void PortMap::Init() {
2  if (mutex_ == NULL) {
3    mutex_ = new Mutex();
4  }
5  prng_ = new Random();
6
7  static const intptr_t kInitialCapacity = 8;
8  if (map_ == NULL) {
9    map_ = new Entry[kInitialCapacity];
10    capacity_ = kInitialCapacity;
11  }
12  memset(map_, 0, capacity_ * sizeof(Entry));
13  used_ = 0;
14  deleted_ = 0;
15} 

2.10.5 ThreadPool初始化

[-> third_party/dart/runtime/vm/thread_pool.cc]

1ThreadPool::ThreadPool()
2    : shutting_down_(false),
3      all_workers_(NULL),
4      idle_workers_(NULL),
5      count_started_(0),
6      count_stopped_(0),
7      count_running_(0),
8      count_idle_(0),
9      shutting_down_workers_(NULL),
10      join_list_(NULL) {} 

2.11 Isolate::InitIsolate

[-> third_party/dart/runtime/vm/isolate.cc]

1Isolate* Isolate::InitIsolate(const char* name_prefix,
2                              const Dart_IsolateFlags& api_flags,
3                              bool is_vm_isolate) {
4  //创建Isolate [2.11.1]
5  Isolate* result = new Isolate(api_flags);
6
7  bool is_service_or_kernel_isolate = false;
8  if (ServiceIsolate::NameEquals(name_prefix)) {
9    is_service_or_kernel_isolate = true;
10  }
11#if !defined(DART_PRECOMPILED_RUNTIME)
12  if (KernelIsolate::NameEquals(name_prefix)) {
13    KernelIsolate::SetKernelIsolate(result);
14    is_service_or_kernel_isolate = true;
15  }
16#endif
17  //初始化堆[见小节2.11.2]
18  Heap::Init(result,
19             is_vm_isolate ? 0 : FLAG_new_gen_semi_max_size * MBInWords,
20             (is_service_or_kernel_isolate ? kDefaultMaxOldGenHeapSize
21                                           : FLAG_old_gen_heap_size) * MBInWords);
22  // [见小节2.11.3]
23  if (!Thread::EnterIsolate(result)) {
24    ... //当进入isolate失败，则关闭并删除isolate，并直接返回
25    return NULL;
26  }
27
28  //创建isolate的消息处理对象 [见小节2.11.4]
29  MessageHandler* handler = new IsolateMessageHandler(result);
30  result->set_message_handler(handler);
31
32  //创建Dart API状态的对象
33  ApiState* state = new ApiState();
34  result->set_api_state(state);
35  // [见小节2.11.5]
36  result->set_main_port(PortMap::CreatePort(result->message_handler()));
37  result->set_origin_id(result->main_port());
38  result->set_pause_capability(result->random()->NextUInt64());
39  result->set_terminate_capability(result->random()->NextUInt64());
40  //设置isolate的名称
41  result->BuildName(name_prefix);
42
43  //将isolate添加到isolates_list_head_列表
44  if (!AddIsolateToList(result)) {
45    //当添加失败，则关闭并删除isolate，并直接返回
46    ...
47  }
48  return result;
49} 

该方法主要功能：

• DartVM初始化过程创建的是名为”vm-isolate”的isolate对象，对于isolate的命名方式：
  • 当指定名称name_prefix，则按指定名，比如此处为”vm-isolate”；
  • 当没有指定名称，则为“isolate-xxx”，此处的xxx为main_port端口号；
• 创建Heap，IsolateMessageHandler，ApiState对象，都保存到该isolate对象的成员变量；
• 如果整个过程执行成功，则将新创建的isolate添加到isolates_list_head_链表；如果失败，则会关闭并删除isolate对象。

2.11.1 Isolate初始化

[-> third_party/dart/runtime/vm/isolate.cc]

1Isolate::Isolate(const Dart_IsolateFlags& api_flags)
2    : BaseIsolate(),
3      user_tag_(0),
4      current_tag_(UserTag::null()),
5      default_tag_(UserTag::null()),
6      ic_miss_code_(Code::null()),
7      object_store_(NULL),
8      class_table_(),
9      single_step_(false),
10      store_buffer_(new StoreBuffer()),
11      marking_stack_(NULL),
12      heap_(NULL),
13      isolate_flags_(0),
14      background_compiler_(NULL),
15      optimizing_background_compiler_(NULL),
16      start_time_micros_(OS::GetCurrentMonotonicMicros()),
17      thread_registry_(new ThreadRegistry()),
18      safepoint_handler_(new SafepointHandler(this)),
19      message_notify_callback_(NULL),
20      name_(NULL),
21      main_port_(0),
22      origin_id_(0),
23      pause_capability_(0),
24      terminate_capability_(0),
25      init_callback_data_(NULL),
26      environment_callback_(NULL),
27      library_tag_handler_(NULL),
28      api_state_(NULL),
29      random_(),
30      simulator_(NULL),
31      ... //省略若干metex
32      message_handler_(NULL),
33      spawn_state_(NULL),
34      defer_finalization_count_(0),
35      pending_deopts_(new MallocGrowableArray<PendingLazyDeopt>()),
36      deopt_context_(NULL),
37      tag_table_(GrowableObjectArray::null()),
38      deoptimized_code_array_(GrowableObjectArray::null()),
39      sticky_error_(Error::null()),
40      reloaded_kernel_blobs_(GrowableObjectArray::null()),
41      next_(NULL),
42      loading_invalidation_gen_(kInvalidGen),
43      boxed_field_list_(GrowableObjectArray::null()),
44      spawn_count_monitor_(new Monitor()),
45      spawn_count_(0),
46      handler_info_cache_(),
47      catch_entry_moves_cache_(),
48      embedder_entry_points_(NULL),
49      obfuscation_map_(NULL),
50      reverse_pc_lookup_cache_(nullptr) {
51  FlagsCopyFrom(api_flags);
52  SetErrorsFatal(true);
53  set_compilation_allowed(true);
54  set_user_tag(UserTags::kDefaultUserTag);
55  ... //DartVM不允许混淆符号
56  if (FLAG_enable_interpreter) {
57    NOT_IN_PRECOMPILED(background_compiler_ = new BackgroundCompiler(this));
58  }
59  NOT_IN_PRECOMPILED(optimizing_background_compiler_ = new BackgroundCompiler(this));
60} 

2.11.2 Heap::Init

[-> third_party/dart/runtime/vm/heap/heap.cc]

1void Heap::Init(Isolate* isolate,
2                intptr_t max_new_gen_words,
3                intptr_t max_old_gen_words) {
4  //创建堆Heap
5  Heap* heap = new Heap(isolate, max_new_gen_words, max_old_gen_words);
6  isolate->set_heap(heap);
7} 

2.11.3 Thread::EnterIsolate

[-> third_party/dart/runtime/vm/thread.cc]

1bool Thread::EnterIsolate(Isolate* isolate) {
2  const bool kIsMutatorThread = true;
3  Thread* thread = isolate->ScheduleThread(kIsMutatorThread);
4  if (thread != NULL) {
5    thread->task_kind_ = kMutatorTask;
6    thread->StoreBufferAcquire();
7    if (isolate->marking_stack() != NULL) {
8      thread->MarkingStackAcquire();
9      thread->DeferredMarkingStackAcquire();
10    }
11    return true;
12  }
13  return false;
14} 

2.11.4 IsolateMessageHandler初始化

[-> third_party/dart/runtime/vm/isolate.cc]

1class IsolateMessageHandler : public MessageHandler {
2 public:
3  explicit IsolateMessageHandler(Isolate* isolate);
4} 

IsolateMessageHandler继承于MessageHandler，MessageHandler中有两个比较重要的成员变量queue_和oob_queue_，用于记录普通消息和oob消息的队列。

2.11.5 PortMap::CreatePort

[-> third_party/dart/runtime/vm/port.cc]

1Dart_Port PortMap::CreatePort(MessageHandler* handler) {
2  MutexLocker ml(mutex_);
3
4  Entry entry;
5  entry.port = AllocatePort();  //采用随机数生成一个整型的端口号
6  entry.handler = handler;
7  entry.state = kNewPort;
8
9  intptr_t index = entry.port % capacity_;
10  Entry cur = map_[index];
11  while (cur.port != 0) {
12    index = (index + 1) % capacity_;
13    cur = map_[index];
14  }
15
16  if (map_[index].handler == deleted_entry_) {
17    deleted_--;
18  }
19  map_[index] = entry;
20
21  used_++;
22  MaintainInvariants();
23  return entry.port;
24} 

map_是一个记录端口entry的HashMap，每一个entry里面有端口号，handler，以及端口状态。

• 端口号port采用的是用随机数生成一个整型的端口号，
• handler是并记录handler指针；
• 端口状态state有3种类型，包括kNewPort(新分配的端口)，kLivePort(普通端口)，kControlPort(特殊控制类的端口)

三、创建Isolate

3.1 DartIsolate::CreateRootIsolate

[-> flutter/runtime/dart_isolate.cc]

1std::weak_ptr<DartIsolate> DartIsolate::CreateRootIsolate(
2    const Settings& settings,
3    fml::RefPtr<const DartSnapshot> isolate_snapshot,
4    fml::RefPtr<const DartSnapshot> shared_snapshot,
5    TaskRunners task_runners,
6    std::unique_ptr<Window> window,
7    fml::WeakPtr<SnapshotDelegate> snapshot_delegate,
8    fml::WeakPtr<IOManager> io_manager,
9    std::string advisory_script_uri,
10    std::string advisory_script_entrypoint,
11    Dart_IsolateFlags* flags) {
12  TRACE_EVENT0("flutter", "DartIsolate::CreateRootIsolate");
13  Dart_Isolate vm_isolate = nullptr;
14  std::weak_ptr<DartIsolate> embedder_isolate;
15
16  //创建DartIsolate[见小节3.2]
17  auto root_embedder_data = std::make_unique<std::shared_ptr<DartIsolate>>(
18      std::make_shared<DartIsolate>(
19          settings, std::move(isolate_snapshot),
20          std::move(shared_snapshot), task_runners,                 
21          std::move(snapshot_delegate), std::move(io_manager),        
22          advisory_script_uri, advisory_script_entrypoint,    
23          nullptr));
24  //[见小节3.4]
25  std::tie(vm_isolate, embedder_isolate) = CreateDartVMAndEmbedderObjectPair(
26      advisory_script_uri.c_str(), advisory_script_entrypoint.c_str(),  
27      nullptr, nullptr, flags,                               
28      root_embedder_data.get(), true, &error);
29
30  std::shared_ptr<DartIsolate> shared_embedder_isolate = embedder_isolate.lock();
31  if (shared_embedder_isolate) {
32    //只有root isolates能和window交互
33    shared_embedder_isolate->SetWindow(std::move(window));
34  }
35  root_embedder_data.release();
36  return embedder_isolate;
37}