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生命週期函式或者控制元件點選事件等回撥函式中做耗時操作。

ArkUI中的執行緒和看門狗機制

一、前言

二、ArkUI中的執行緒

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

四、ArkUI中的看門狗

相關文章