ArkUI 中的線程和看門狗機制

一、前言

本文主要分析 ArkUI 中涉及的線程和看門狗機制。

二、ArkUI 中的線程

應用 Ability 首次創建界面的流程大致如下：

說明：

?AceContainer 是一個容器類，由前端、任務執行器、資源管理器、渲染管線、視圖等聚合而成，提供了生命周期對接、功能調度接口和 UI 渲染的各項能力。

?Ability 在 FA 模型中實際為 AceAbility，和 AceContainer 容器類搭配管理界面。在 AceAbility 的生命周期函數 AceAbility::OnStart (const Want& want) 中創建 AceContainer 實例。

?對于 Stage 模型，在 UIContentImpl::CommonInitialize () 函數中創建 AceContainer 實例。AceContainer 在構造函數中創建任務執行器，用于執行 ArkUI 相關任務。

void AceContainer::InitializeTask()
{
 auto flutterTaskExecutor = Referenced::MakeRefPtr();
 flutterTaskExecutor->InitPlatformThread(useCurrentEventRunner_);
 taskExecutor_ = flutterTaskExecutor;
 // No need to create JS Thread for DECLARATIVE_JS
 if (type_ == FrontendType::DECLARATIVE_JS) {
 GetSettings().useUIAsJSThread = true;
 } else {
 flutterTaskExecutor->InitJsThread();
 }
}

任務有如下幾種類型，每種類型 (BACKGROUND 任務除外) 的任務會由一個 fml::TaskRunner 去執行。TaskRunner 代碼在三方庫 third_partyflutterenginefluttercommontask_runners.h 中，實現原理和 EventRunner，EventHandler 機制相似。

 enum class TaskType : uint32_t {
 PLATFORM = 0,
 UI,
 IO,
 GPU,
 JS,
 BACKGROUND,
 UNKNOWN,
 };

FlutterTaskExecutor 類圖如下：

說明：

?任務執行器可以用于執行異步 (PostTask) 和同步 (PostSyncTask) 任務。

?異步任務：把任務丟給指定類型的線程處理，不會阻塞當前線程。

?同步任務：把任務丟給指定類型的線程處理并阻塞當前線程，直到任務執行完后繼續當前線程。

?比如觸摸事件的處理，會以異步任務的形式被丟到 UI 線程中處理。

 auto&& touchEventCallback = [context = pipelineContext_, id = instanceId_](
 const TouchEvent& event, const std::function& markProcess) {
 ContainerScope scope(id);
 context->GetTaskExecutor()->PostTask(
 [context, event, markProcess]() {
 context->OnTouchEvent(event);
 CHECK_NULL_VOID_NOLOG(markProcess);
 markProcess();
 },
 TaskExecutor::TaskType::UI);
 };

三、各種類型的 TaskRunner 如何初始化？

platformRunner_

在 InitPlatformThread 函數中初始化。

void FlutterTaskExecutor::InitPlatformThread(bool useCurrentEventRunner)
{
#ifdef OHOS_STANDARD_SYSTEM
 platformRunner_ = flutter::PlatformTaskRunner::CurrentTaskRunner(useCurrentEventRunner);
#else
 fml::MessageLoop::EnsureInitializedForCurrentThread();
 platformRunner_ = fml::MessageLoop::GetCurrent().GetTaskRunner();
#endif

 FillTaskTypeTable(TaskType::PLATFORM);
}

對于標準 OHOS，platformRunner_實際為

flutter::PlatformTaskRunner::CurrentTaskRunner(useCurrentEventRunner)

看下具體實現：

fml::RefPtr PlatformTaskRunner::CurrentTaskRunner(bool useCurrentEventRunner)
{
 return PlatformTaskRunnerAdapter::CurrentTaskRunner(useCurrentEventRunner);
}

fml::RefPtr PlatformTaskRunnerAdapter::CurrentTaskRunner(bool useCurrentEventRunner)
{
 if (useCurrentEventRunner) {
 return fml::MakeRefCounted(useCurrentEventRunner);
 }
 if (taskRunner_) {
 return taskRunner_;
 }
 taskRunner_ = fml::MakeRefCounted(useCurrentEventRunner);
 return taskRunner_;
}

說明：

platformRunner 實際類型為 PlatformTaskRunnerAdapter。

PlatformTaskRunnerAdapter 繼承自 fml::TaskRunner，實現了 virtual void PostTask (fml::closure task) 等接口函數。實際是在 EventRunner，EventHandler 機制基礎上又做了層封裝。代碼中 useCurrentEventRunner 實參為 false。意味著 platformRunner 實際是把任務丟給主線程去做的。(MainEventRunner 對應的線程為主線程，MainEventRunner 的初始化在 Ability 框架 MainThread::Start () 函數中)

PlatformTaskRunnerAdapter::PlatformTaskRunnerAdapter(bool useCurrentEventRunner)
 : fml::TaskRunner(nullptr)
{
 if (useCurrentEventRunner) {
 eventRunner_ = OHOS::AppExecFwk::EventRunner::Current();
 } else {
 eventRunner_ = OHOS::AppExecFwk::EventRunner::GetMainEventRunner();
 }
 eventHandler_ = std::make_shared(eventRunner_);
}

void PlatformTaskRunnerAdapter::PostTask(fml::closure task)
{
 eventHandler_->PostTask(std::move(task));
}
 

uiRunner, ioRunner, gpuRunner_

這三種類型的 TaskRunner 初始化都在 FlutterTaskExecutor::InitOtherThreads 函數中。

void FlutterTaskExecutor::InitOtherThreads(const flutter::TaskRunners& taskRunners)
{
 uiRunner_ = taskRunners.GetUITaskRunner();
 ioRunner_ = taskRunners.GetIOTaskRunner();
#ifdef NG_BUILD
 gpuRunner_ = taskRunners.GetRasterTaskRunner();
#else
 gpuRunner_ = taskRunners.GetGPUTaskRunner();
#endif

 //...此處省略若干行
}

FlutterTaskExecutor::InitOtherThreads 函數的參數 taskRunners 從哪來？

FlutterAceView::CreateView () 函數中會初始化一些配置項，然后創建 flutter::OhosShellHolder 對象。

FlutterAceView* FlutterAceView::CreateView(int32_t instanceId, bool useCurrentEventRunner, bool usePlatformThread)
{
 FlutterAceView* aceSurface = new Platform::FlutterAceView(instanceId);
 if (aceSurface != nullptr) {
 aceSurface->IncRefCount();
 }
 flutter::Settings settings;
 settings.instanceId = instanceId;
 settings.platform = flutter::AcePlatform::ACE_PLATFORM_OHOS;
#ifndef GPU_DISABLED
 settings.enable_software_rendering = false;
#else
 settings.enable_software_rendering = true;
#endif
#ifdef ENABLE_ROSEN_BACKEND
 settings.use_system_render_thread = SystemProperties::GetRosenBackendEnabled();
#endif
 settings.platform_as_ui_thread = usePlatformThread;
 settings.use_current_event_runner = useCurrentEventRunner;
 // ...此處省略若干行
 auto shell_holder = std::make_unique(settings, false);
 if (aceSurface != nullptr) {
 aceSurface->SetShellHolder(std::move(shell_holder));
 }
 return aceSurface;
}

OhosShellHolder 構造函數中會根據傳入的參數創建 flutter::TaskRunners。

OhosShellHolder::OhosShellHolder(
 flutter::Settings settings,
 bool is_background_view)
 : settings_(std::move(settings))
{
 // ...此處省略若干行
 // The current thread will be used as the platform thread. Ensure that the
 // message loop is initialized.
 fml::MessageLoop::EnsureInitializedForCurrentThread();
 fml::RefPtr gpu_runner;
 fml::RefPtr ui_runner;
 fml::RefPtr io_runner;
 fml::RefPtr platform_runner =
 PlatformTaskRunnerAdapter::CurrentTaskRunner(settings_.use_current_event_runner);
 if (is_background_view) {
 auto single_task_runner = thread_host_.ui_thread->GetTaskRunner();
 gpu_runner = single_task_runner;
 ui_runner = single_task_runner;
 io_runner = single_task_runner;
 } else {
 if (settings_.platform_as_ui_thread) {
 ui_runner = platform_runner;
 } else {
 ui_runner = thread_host_.ui_thread->GetTaskRunner();
 }
 if (!settings_.use_system_render_thread) {
 gpu_runner = thread_host_.gpu_thread->GetTaskRunner();
 } else {
 gpu_runner = ui_runner;
 }
 if (settings_.use_io_thread) {
 io_runner = thread_host_.io_thread->GetTaskRunner();
 } else {
 io_runner = ui_runner;
 }
 }
 flutter::TaskRunners task_runners(thread_label, // label
 platform_runner, // platform
 gpu_runner, // gpu
 ui_runner, // ui
 io_runner // io
 );
 

說明：目前 OHOS 上，配置的參數如下：

對照上面的代碼段，實際 gpu_runner，ui_runner，io_runner 是同一個，任務都在 UI 線程執行。另外對于 Stage 模型，ui_runner 和 platform_runner 又是同一個，所以對 Stage 模型來說，TaskType::UI，TaskType::IO，TaskType::GPU，TaskType::PLATFORM 類型的任務實際都是由主線程來執行的。

jsRunner_

初始化在 FlutterTaskExecutor::InitJsThread (bool newThread) 函數中。

void FlutterTaskExecutor::InitJsThread(bool newThread)
{
 if (newThread) {
 jsThread_ = std::make_unique(GenJsThreadName());
 jsRunner_ = jsThread_->GetTaskRunner();
 } else {
 jsRunner_ = uiRunner_;
 }

 PostTaskToTaskRunner(
 jsRunner_, [weak = AceType::WeakClaim(this)] { FillTaskTypeTable(weak, TaskType::JS); }, 0);
}

說明：對于聲明式前端，newThread 參數為 false; JS 前端為 true。所以聲明式前端 JS 線程實際為 UI 線程；而對于 JS 前端，會起獨立的 JS 線程來處理 JS 相關的任務。

TaskType::BACKGROUND 類型的任務如何執行？

TaskType::BACKGROUND 類型的任務會由單例 BackgroundTaskExecutor 去執行。BackgroundTaskExecutor 中維護了一個 8 個線程的線程池，用來處理后臺耗時操作。線程名以 “ace.bg.” 開頭。比如 RosenFontLoader 在加載網絡字體的時候，下載操作會放到后臺任務線程里去做。

void RosenFontLoader::LoadFromNetwork(const OHOS::Ace::RefPtr& context)
{
 auto weakContext = AceType::WeakClaim(AceType::RawPtr(context));
 context->GetTaskExecutor()->PostTask(
 [weak = AceType::WeakClaim(this), weakContext] {
 auto fontLoader = weak.Upgrade();
 auto context = weakContext.Upgrade();
 if (!fontLoader || !context) {
 return;
 }
 std::vector fontData;
 if (!DownloadManager::GetInstance().Download(fontLoader->familySrc_, fontData) || fontData.empty()) {
 return;
 }
 //...此處省略若干行
 },
 TaskExecutor::TaskType::BACKGROUND);
}

綜上：在 ArkUI 中，會為每個帶界面的 Ability 創建一個 AceContainer, 每個 AceContainer 中會創建一個 FlutterTaskExecutor 用于處理該 Ability ArkUI 相關的任務。根據不同的模型，ArkUI 創建出來的線程會有所不同：

?對于 Stage 模型的應用，ui 線程復用了主線程，并且 Stage 模型應用目前都是聲明式前端，導致 js 線程又復用了 ui 線程。所以 ArkUI 只需另外創建名字以 “ace.bg.” 開頭的八個后臺任務線程。

?對于 FA 模型的應用，除了八個后臺任務線程，根據 Ability 的數量會創建若干個名字以 “.ui” 結尾的線程。如果是 JS 前端，還會創建若干個名字以 “jsThread-” 開頭的線程。

四、ArkUI 中的看門狗

AceEngine 是單例，全局唯一。AceEngine 的構造函數中會創建 WatchDog 實例。對于 FA 模型的應用，AceContainer::AttachView () 函數中通過調用

AceEngine::Get().RegisterToWatchDog(instanceId, taskExecutor_,

GetSettings().useUIAsJSThread);

把持有的 FlutterTaskExecutor 注冊到看門狗中看護。

看門狗只看護 FlutterTaskExecutor 中的 UI 線程和 JS 線程。Stage 模型的應用由于 UI 線程和 JS 線程實際是復用的主線程，所以不需要在 ArkUI 中看護。Ability 框架中有看門狗專門看護主線程。如果線程中有任務處理超過了 3s，會上報 RawEventType::WARNING 對應的系統事件給 hiview 插件平臺；如果任務處理超過了 5s，會上報 RawEventType::FREEZE 對應的系統事件給 hiview 插件平臺，hiview 插件平臺會生成 appfreeze 的 dump 文件。

為了防止主線程和 ui 線程卡住引起 appfreeze，做應用開發的時候，不要在 Ability 生命周期函數或者控件點擊事件等回調函數中做耗時操作。

審核編輯 黃宇