关于openharmony: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>();    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_party\flutter\engine\flutter\common\task_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<void()>& 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<fml::TaskRunner> PlatformTaskRunner::CurrentTaskRunner(bool useCurrentEventRunner){    return PlatformTaskRunnerAdapter::CurrentTaskRunner(useCurrentEventRunner);}

fml::RefPtr<fml::TaskRunner> PlatformTaskRunnerAdapter::CurrentTaskRunner(bool useCurrentEventRunner){    if (useCurrentEventRunner) {        return fml::MakeRefCounted<PlatformTaskRunnerAdapter>(useCurrentEventRunner);    }    if (taskRunner_) {        return taskRunner_;    }    taskRunner_ = fml::MakeRefCounted<PlatformTaskRunnerAdapter>(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<OHOS::AppExecFwk::EventHandler>(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<flutter::OhosShellHolder>(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<fml::TaskRunner> gpu_runner;  fml::RefPtr<fml::TaskRunner> ui_runner;  fml::RefPtr<fml::TaskRunner> io_runner;  fml::RefPtr<fml::TaskRunner> 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<fml::Thread>(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<OHOS::Ace::PipelineBase>& 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<uint8_t> 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生命周期函数或者控件点击事件等回调函数中做耗时操作。