关于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生命周期函数或者控件点击事件等回调函数中做耗时操作。

关于openharmony:ArkUI中的线程和看门狗机制

一、前言

二、ArkUI中的线程

三、各种类型的TaskRunner如何初始化？

四、ArkUI中的看门狗

评论

发表回复取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

关于openharmony:ArkUI中的线程和看门狗机制

一、前言

二、ArkUI中的线程

三、各种类型的TaskRunner如何初始化？

四、ArkUI中的看门狗

评论

发表回复 取消回复

更多文章

DDN HPC 存储硬件架构设计深度分析

探秘IO500：从Lustre并行文件系统出发，开启HPC存储性能新征程

苹果iOS打包的ipa应用无法安装？一篇文章带你了解可能的原因及排查方法

图解Golang：从零开始实现简易版过期LRU缓存

发表回复取消回复