本文为稀土技术社区首发签约文章，30天内制止转载，30天后未获授权制止转载，侵权必究！

引言

本篇是ArkUI Engine 系列的第五篇，经过前四篇文章，相信读者能够掌握一个ArkUI控件最重要的绘制进程与事情绑定进程的原理了，控件的绘制是Engine中的主要流程。当然，Engine做的不只是UI的绘制工作，还有一个流通度监控体系，即WatchDog机制。

经过学习本篇，你将了解到鸿蒙的WatchDog机制与ANR（使用无呼应）断定相关的代码细节，便利咱们进行后续的性能监控与优化。

WatchDog

无论是哪个UI体系，都有着体系流通度监控的需求，鸿蒙也不破例，当咱们遇到以下代码时，点击Text就会进入死循环，此刻咱们再次进行点击事情，就会出现咱们熟知的ANR弹窗

Column() {
  Text(this.father.name)
    .width("200vp")
    .onClick(() => {
      while (true){
      }
    })

ANR弹窗如下：

ANR的检测，其实就经过WatchDog 机制完结的，下面咱们来详细了解一下WatchDog机制

WatchDog 初始化

WatchDog机制中，有两个相关的类，一个是Watchers 结构体，另一个是WatchDog类，WatchDog中会有一个持有着value为Watchers的map

namespace OHOS::Ace {
class ThreadWatcher;
struct Watchers {
    RefPtr<ThreadWatcher> jsWatcher;
    RefPtr<ThreadWatcher> uiWatcher;
};
class WatchDog final : public Referenced {
public:
    WatchDog();
    ~WatchDog() override;
    void Register(int32_t instanceId, const RefPtr<TaskExecutor>& taskExecutor, bool useUIAsJSThread);
    void Unregister(int32_t instanceId);
    void BuriedBomb(int32_t instanceId, uint64_t bombId);
    void DefusingBomb(int32_t instanceId);
private:
    std::unordered_map<int32_t, Watchers> watchMap_;
    ACE_DISALLOW_COPY_AND_MOVE(WatchDog);
};
} // namespace OHOS::Ace

WatchDog在结构函数的时分，会创立发动一个AnrThread

WatchDog::WatchDog()
{
    AnrThread::Start();
#if defined(OHOS_PLATFORM) || defined(ANDROID_PLATFORM)
    AnrThread::PostTaskToTaskRunner(InitializeGcTrigger, GC_CHECK_PERIOD);
#endif
}

AnrThread界说也很简单，它用于一个事情循环的才能，即像Android的Looper相同不断进行事情的分发

namespace OHOS::Ace {
class AnrThread {
public:
    static void Start();
    static void Stop();
    using Task = std::function<void()>;
    static bool PostTaskToTaskRunner(Task&& task, uint32_t delayTime);
};
} // namespace OHOS::Ace
#endif

事情分发的才能是由TaskRunnerAdapter类供给的，TaskRunnerAdapter抽象了事情分发的才能，它的事情可所以任何具有才能分发的类供给，比方（OHOS::AppExecFwk::EventRunner）

namespace {
需要一个TaskRunnerAdapter，用于事情的分发
RefPtr<TaskRunnerAdapter> g_anrThread;
} // namespace
void AnrThread::Start()
{
    if (!g_anrThread) {
        g_anrThread = TaskRunnerAdapterFactory::Create(false, "anr");
    }
}
void AnrThread::Stop()
{
    g_anrThread.Reset();
}
bool AnrThread::PostTaskToTaskRunner(Task&& task, uint32_t delayTime)
{
    if (!g_anrThread || !task) {
        return false;
    }
    if (delayTime > 0) {
        g_anrThread->PostDelayedTask(std::move(task), delayTime, {});
    } else {
        g_anrThread->PostTask(std::move(task), {});
    }
    return true;
}
} // namespace OHOS::Ace

初始化的动作很简单，即发动一个具有事情循环机制的类，用于后边进行事情的循环分发，一起当时渠道假如界说了这两个宏情况下OHOS_PLATFORM或者ANDROID_PLATFORM， 那么将会建议第一个事情，用于GC信号的注册。没错，Engine中需要经过信号触发GC，经过注册自界说信号SIGNAL_FOR_GC（60）来进行信号绑定


void InitializeGcTrigger()
{
    // Record watch dog thread as signal handling thread
    g_signalThread = pthread_self();
    int32_t result = BlockGcSignal();
    if (result != 0) {
        LOGE("Failed to block GC signal, errno = %{public}d", result);
        return;
    }
    // Start to receive GC signal
    signal(SIGNAL_FOR_GC, OnSignalReceive);
    // Start check GC signal
    CheckGcSignal();
}

CheckGcSignal 经过sigtimedwait函数，用于当必定时刻内等待信号降临，假如在时刻内有收到信号，那么顺利履行AceEngine::Get().TriggerGarbageCollection();办法进行GC。（sigtimedwait 超时时result会小于0一起errno会被设置为EAGAIN，一起判别EINTR的目的是其他信号降临时也会打断sigtimedwait调用）

void CheckGcSignal()
{
    // Check if GC signal is in pending signal set
    sigset_t sigSet;
    sigemptyset(&sigSet);
    sigaddset(&sigSet, SIGNAL_FOR_GC);
    struct timespec interval = {
        .tv_sec = 0,
        .tv_nsec = 0,
    };
    int32_t result = sigtimedwait(&sigSet, nullptr, &interval);
    if (result < 0) {
        if (errno != EAGAIN && errno != EINTR) {
            LOGE("Failed to wait signals, errno = %{public}d", errno);
            return;
        }
    } else {
        ACE_DCHECK(result == SIGNAL_FOR_GC);
        // Start GC
        LOGE("Receive GC signal");
        AceEngine::Get().TriggerGarbageCollection();
    }
    // Check again
    AnrThread::AnrThread::PostTaskToTaskRunner(CheckGcSignal, GC_CHECK_PERIOD);
}

至此，WatchDog事情循环机制已经完结初始化，能够承受后边的“埋炸弹”与“拆炸弹”动作了

ANR机制

WatchDog 经过露出Register 办法，供给给Engine以外的模块进行注册，注册之后就能够使用WatchDog的监控

void WatchDog::Register(int32_t instanceId, const RefPtr<TaskExecutor>& taskExecutor, bool useUIAsJSThread)
{
    Watchers watchers = {
        .jsWatcher = AceType::MakeRefPtr<ThreadWatcher>(instanceId, TaskExecutor::TaskType::JS),
        .uiWatcher = AceType::MakeRefPtr<ThreadWatcher>(instanceId, TaskExecutor::TaskType::UI, useUIAsJSThread),
    };
    watchers.uiWatcher->SetTaskExecutor(taskExecutor);
    if (!useUIAsJSThread) {
        watchers.jsWatcher->SetTaskExecutor(taskExecutor);
    } else {
        watchers.jsWatcher = nullptr;
    }
    const auto resExecutor = watchMap_.try_emplace(instanceId, watchers);
    if (!resExecutor.second) {
        LOGW("Duplicate instance id: %{public}d when register to watch dog", instanceId);
    }
}

在ArkTS环境中，WatchDog只会创立uiWatcher并赋值给结构体（Watchers的uiWatcher），它是一个ThreadWatcher目标

ThreadWatcher目标初始化的时分，将发动检查，经过AnrThread::PostTaskToTaskRunner发动了一个检查使命

ThreadWatcher::ThreadWatcher(int32_t instanceId, TaskExecutor::TaskType type, bool useUIAsJSThread)
    : instanceId_(instanceId), type_(type), useUIAsJSThread_(useUIAsJSThread)
{
    InitThreadName();
    AnrThread::PostTaskToTaskRunner(
        [weak = Referenced::WeakClaim(this)]() {
            auto sp = weak.Upgrade();
            CHECK_NULL_VOID(sp);
             调用了ThreadWatcherCheck办法
            sp->Check();
        },
        NORMAL_CHECK_PERIOD);
}

Check办法是整个ANR机制中最核心的完成，下面咱们来看一下代码


void ThreadWatcher::Check()
{
    int32_t period = NORMAL_CHECK_PERIOD;
    if (!IsThreadStuck()) {
        if (state_ == State::FREEZE) {
            RawReport(RawEventType::RECOVER);
        }
        freezeCount_ = 0;
        state_ = State::NORMAL;
        canShowDialog_ = true;
        showDialogCount_ = 0;
    } else {
        if (state_ == State::NORMAL) {
            HiviewReport();
            RawReport(RawEventType::WARNING);
            state_ = State::WARNING;
            period = WARNING_CHECK_PERIOD;
        } else if (state_ == State::WARNING) {
            RawReport(RawEventType::FREEZE);
            state_ = State::FREEZE;
            period = FREEZE_CHECK_PERIOD;
            DetonatedBomb();
        } else {
            if (!canShowDialog_) {
                showDialogCount_++;
                if (showDialogCount_ >= ANR_DIALOG_BLOCK_TIME) {
                    canShowDialog_ = true;
                    showDialogCount_ = 0;
                }
            }
            if (++freezeCount_ >= 5) {
                RawReport(RawEventType::FREEZE);
                freezeCount_ = 0;
            }
            period = FREEZE_CHECK_PERIOD;
            DetonatedBomb();
        }
    }
    check使命完结后，继续进行check使命
    AnrThread::PostTaskToTaskRunner(
        [weak = Referenced::WeakClaim(this)]() {
            auto sp = weak.Upgrade();
            CHECK_NULL_VOID(sp);
            sp->Check();
        },
        period);
}

为了理解上面的代码，咱们简单总结一下上面提到的三种状况，分别是NORMAL，WARNING，FREEZE

NORMAL

NORMAL状况是正常的状况，咱们能够看到，当IsThreadStuck返回false时，state变量就会被设置为NORMAL状况，咱们看一下IsThreadStuck办法

bool ThreadWatcher::IsThreadStuck()
{
        ...
        要害的判别逻辑在这儿
        if (((loopTime_ - threadTag_) > (lastLoopTime_ - lastThreadTag_)) && (lastTaskId_ == taskId)) {
            std::string abilityName;
            if (AceEngine::Get().GetContainer(instanceId_) != nullptr) {
                abilityName = AceEngine::Get().GetContainer(instanceId_)->GetHostClassName();
            }
            LOGE("thread stuck, ability: %{public}s, instanceId: %{public}d, thread: %{public}s, looptime: %{public}d, "
                 "checktime: %{public}d",
                abilityName.c_str(), instanceId_, threadName_.c_str(), loopTime_, threadTag_);
            res = true;
        }
        lastTaskId_ = taskId;
        lastLoopTime_ = loopTime_;
        lastThreadTag_ = threadTag_;
    }
    CheckAndResetIfNeeded();
    PostCheckTask();
    return res;
}

这儿边触及了非常要害的两个变量loopTime_ ，与threadTag_ 。咱们能够想一下，ANR假如发生时，必定是音讯循环的某个音讯履行时刻过长才会导致的，那么如何判别音讯履行时刻呢？就靠这两个变量


void ThreadWatcher::PostCheckTask()
{
    auto taskExecutor = taskExecutor_.Upgrade();
    if (taskExecutor) {
        // post task to specified thread to check it
        taskExecutor->PostTask(
            [weak = Referenced::WeakClaim(this)]() {
                auto sp = weak.Upgrade();
                CHECK_NULL_VOID(sp);
                每次真正履行一个task，threadTag_ 才会自增
                sp->TagIncrease();
            },
            type_);
        std::unique_lock<std::shared_mutex> lock(mutex_);
        每次调用PostCheckTask的时分，loopTime_都会自增
        ++loopTime_;
     ....
}
void ThreadWatcher::TagIncrease()
{
    std::unique_lock<std::shared_mutex> lock(mutex_);
    ++threadTag_;
}

loopTime_ ：每次engine调用PostCheckTask的时分，就会自增

threadTag_： 每次使命被调度的时分，就会自增

正常情况下，loopTime_都约等于threadTag_，调用PostCheckTask的时分假如没有delay的话，理应使命也会被调度。但是假如处在异常情况，比方这个task是一个耗时履行，比方一个死循环被调度，那么这两个变量的差值会跟着PostCheckTask的调用被不断增大，然后断定为线程卡顿。当然，这儿还一起判别了当时使命与前一个使命的id，两者假如相同，那么就大大证明了这个task存在卡顿。

假如处于无卡顿状况，那么state变量就会被赋值为NORMAL状况。

WARNING

WARNING是一个中间状况，咱们在上文IsThreadStuck函数能够看到，履行完IsThreadStuck后就会又调用PostCheckTask函数，再次向音讯循环中抛出一个check函数履行。

假如IsThreadStuck返回了false，那么state就会被当即设置为WARNING状况，假如音讯循环中的check函数再次被调度时仍是IsThreadStuck返回了false，那么就当即升级为FREEZE状况

FREEZE

FREEZE 状况是ANR的充分状况，因为两次音讯循环中IsThreadStuck都返回了false，那么此刻就会调用DetonatedBomb进行“炸弹引爆”。

值得注意的是，咱们还有一个else分支，即屡次音讯循环中，上一次状况为FREEZE，下一次状况依然为FREEZE，那么当累计次数达到ANR_DIALOG_BLOCK_TIME（5）次时，将再次把canShowDialog_修改为true（canShowDialog_控制着是否弹出ANR弹窗，当上一次ANR弹窗弹出时会被设置为false，因此只需再超过5次时，就会再次把这个变量设置为true让ANR弹窗再次可弹。）。同样的，假如屡次处于FREEZE状况，那么每一次都会调用DetonatedBomb函数“引爆炸弹”

        } else if (state_ == State::WARNING) {
            RawReport(RawEventType::FREEZE);
            state_ = State::FREEZE;
            period = FREEZE_CHECK_PERIOD;
            DetonatedBomb();
        } else {
            if (!canShowDialog_) {
                showDialogCount_++;
                if (showDialogCount_ >= ANR_DIALOG_BLOCK_TIME) {
                    canShowDialog_ = true;
                    showDialogCount_ = 0;
                }
            }
            if (++freezeCount_ >= 5) {
                RawReport(RawEventType::FREEZE);
                freezeCount_ = 0;
            }
            period = FREEZE_CHECK_PERIOD;
            DetonatedBomb();
        }

“引爆炸弹”&“埋炸弹”&“拆炸弹”

咱们上面提到的“引爆炸弹”，其实就是指DetonatedBomb函数，它用于触发ANR使命，假如满足条件的情况下。

当然，DetonatedBomb并不是调用了就会产生ANR弹窗，而是会判别inputTaskIds_中第一个使命与当时运行使命的时刻差值是否大于ANR_INPUT_FREEZE_TIME（5000 即5s），假如大于这个阈值那么毫无疑问是一个ANR，不然就只是一个卡顿。假如canShowDialog_为true，那么就调用ShowDialog办法弹出ANR弹窗

void ThreadWatcher::DetonatedBomb()
{
    std::shared_lock<std::shared_mutex> lock(mutex_);
    会先判别inputTaskIds_这个行列是否为空
    if (inputTaskIds_.empty()) {
        return;
    }
    uint64_t currentTime = GetMilliseconds();
    uint64_t bombId = inputTaskIds_.front();
    if (currentTime - bombId > ANR_INPUT_FREEZE_TIME) {
        LOGE("Detonated the Bomb, which bombId is %{public}s and currentTime is %{public}s",
            std::to_string(bombId).c_str(), std::to_string(currentTime).c_str());
        if (canShowDialog_) {
            ShowDialog();
            canShowDialog_ = false;
            showDialogCount_ = 0;
        } else {
            LOGE("Can not show dialog when detonated the Bomb.");
        }
        ANR断定成功后会把整个炸弹行列清除
        std::queue<uint64_t> empty;
        std::swap(empty, inputTaskIds_);
    }
}

inputTaskIds_变量其实是一个行列

std::queue<uint64_t> inputTaskIds_;

使用者能够经过BuriedBomb进行“埋炸弹”，用于要害的流程进行ANR判别

void ThreadWatcher::BuriedBomb(uint64_t bombId)
{
    std::unique_lock<std::shared_mutex> lock(mutex_);
    inputTaskIds_.emplace(bombId);
}

当然，使用者也能够经过DefusingBomb办法进行“拆炸弹”

void ThreadWatcher::DefusingBomb()
{
    auto taskExecutor = taskExecutor_.Upgrade();
    CHECK_NULL_VOID(taskExecutor);
    taskExecutor->PostTask(
        [weak = Referenced::WeakClaim(this)]() {
            auto sp = weak.Upgrade();
            if (sp) {
                sp->DefusingTopBomb();
            }
        },
        type_);
}

实质都是对这个行列的元素进行增删操作，因为后续触发DetonatedBomb办法的时分，会先判别inputTaskIds_是否为空，假如为空的情况下，那么其实就算音讯推迟也不算为ANR。

总结

经过本章，咱们学习到Engine供给的WatchDog机制以及其ANR完成的原理，经过学习这些源码，咱们将会对整个ArkUIEngine更加的熟悉，便利咱们进行后续的监控或者优化。

ArkUI Engine – 深入ANR机制

引言

WatchDog

WatchDog 初始化

ANR机制

NORMAL

WARNING

FREEZE

“引爆炸弹”&“埋炸弹”&“拆炸弹”

总结

作者信息

ArkUI Engine – 深入ANR机制

引言

WatchDog

WatchDog 初始化

ANR机制

NORMAL

WARNING

FREEZE

“引爆炸弹”&“埋炸弹”&“拆炸弹”

总结

相关文章

ArkUI-x 视频播放App初出茅庐

离开OpenAI待业的Karpathy做了个大模型新项目，Star量一日破千

Go1.21 速览：新内置函数 clear、min、max 和新标准库包 cmp！

面试串讲009-布局层级太多怎么优化？

作者信息