乐趣区

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

jiezi

一、前言

本文次要剖析 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 如何初始化？

  1. platformRunner_

  2. 在 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));
}
  1. 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 类型的工作理论都是由主线程来执行的。

  1. 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 相干的工作。

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

退出移动版