一、前言

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

二、ArkUI 中的線程

應用 Ability 首次創(chuàng)建界面的流程大致如下：

說明：

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

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

?對于 Stage 模型，在 UIContentImpl::CommonInitialize () 函數(shù)中創(chuàng)建 AceContainer 實例。AceContainer 在構造函數(shù)中創(chuàng)建任務執(zhí)行器，用于執(zhí)行 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 去執(zhí)行。TaskRunner 代碼在三方庫 third_partyflutterenginefluttercommontask_runners.h 中，實現(xiàn)原理和 EventRunner，EventHandler 機制相似。

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

FlutterTaskExecutor 類圖如下：

說明：

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

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

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

?比如觸摸事件的處理，會以異步任務的形式被丟到 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 函數(shù)中初始化。

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)

看下具體實現(xiàn)：

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，實現(xiàn)了 virtual void PostTask (fml::closure task) 等接口函數(shù)。實際是在 EventRunner，EventHandler 機制基礎上又做了層封裝。代碼中 useCurrentEventRunner 實參為 false。意味著 platformRunner 實際是把任務丟給主線程去做的。(MainEventRunner 對應的線程為主線程，MainEventRunner 的初始化在 Ability 框架 MainThread::Start () 函數(shù)中)

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 函數(shù)中。

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 函數(shù)的參數(shù) taskRunners 從哪來？

FlutterAceView::CreateView () 函數(shù)中會初始化一些配置項，然后創(chuàng)建 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 構造函數(shù)中會根據(jù)傳入的參數(shù)創(chuàng)建 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 上，配置的參數(shù)如下：

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

jsRunner_

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

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 參數(shù)為 false; JS 前端為 true。所以聲明式前端 JS 線程實際為 UI 線程；而對于 JS 前端，會起獨立的 JS 線程來處理 JS 相關的任務。

TaskType::BACKGROUND 類型的任務如何執(zhí)行？

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

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 創(chuàng)建一個 AceContainer, 每個 AceContainer 中會創(chuàng)建一個 FlutterTaskExecutor 用于處理該 Ability ArkUI 相關的任務。根據(jù)不同的模型，ArkUI 創(chuàng)建出來的線程會有所不同：

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

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

四、ArkUI 中的看門狗

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

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

GetSettings().useUIAsJSThread);

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

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

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

審核編輯 黃宇