一个非常实用的鸿蒙监测组件！

https://gitee.com/isrc_ohos/anr-watch-dog-ohos

//导入ANRError类和ANRWatchDog类
import com.github.anrwatchdog.ANRError;
import com.github.anrwatchdog.ANRWatchDog;
//实例化ANRWatchDog类对象
ANRWatchDog anrWatchDog = new ANRWatchDog(2000);//设置阻塞响应时间为2000毫秒（2秒）

//重写onInitialize()方法
@Override
public void onInitialize() {
    super.onInitialize();
    //设置ANRListener监听
    anrWatchDog.setANRListener(new ANRWatchDog.ANRListener() { 
                   @Override//设置监测到ANR错误后的具体响应行为
                   public void onAppNotResponding(ANRError error) {
                       ...
                       throw error;//直接抛出错误异常，程序闪退  }
            })
            .setANRInterceptor(new ANRWatchDog.ANRInterceptor() {
                @Override//定义拦截器来决定是否提前或推迟
                public long intercept(long duration) {...}
            });
    anrWatchDog.setIgnoreDebugger(true).start();//在debug的情况下也能抛出ANR异常
}

final ANRWatchDog.ANRListener silentListener = new ANRWatchDog.ANRListener() {
    @Override//重写setANRListner()方法
    public void onAppNotResponding(ANRError error) {//自定义ANRListener回调
        HiLog.error(new HiLogLabel(HiLog.LOG_APP,0,"ANR-Watchdog-Demo"), "", error);
    }
};

private static void Sleep() {//模拟线程休眠的情况
    try {
        Thread.sleep(8 * 1000);//线程休眠8秒后释放锁
    }
    catch (InterruptedException e) {
        e.printStackTrace();
    }
}

private static void InfiniteLoop() {//模拟线程无限循环的情况
    int i = 0;
    while (true) {//判断条件恒为true，则无限循环
        i++;
    }
}

private  void  lock(){//模拟线程死锁的情况
    new Thread(){
        @Override
        public void run(){
            synchronized (MainAbility.this){//线程占用锁
                try{
                    Thread.sleep(60000);//休眠60秒后释放锁
                }
            ...}
    }.start();
    synchronized (MainAbility.this){//主线程也同时占用锁
        HiLog.info(new HiLogLabel(HiLog.LOG_APP,0,"ANR-Failed"),"主线程也申请锁");

<DirectionalLayout//创建整体布局
    xmlns:ohos="http://schemas.huawei.com/res/ohos"
    ohos:height="match_parent"
    ohos:width="match_parent"
    ohos:orientation="vertical">
    ...
    //图1红框中的按钮
    <Button         //阻塞响应时间按钮
        ohos:id="$+id:minAnrDuration"
        ohos:width="match_content"
        ohos:height="match_content"
        ohos:text="2s"
   ohos:text_size="150"/>
        ...      //报告模式按钮和响应行为按钮同上
//图1红框中的按钮
    <Button     //线程休眠按钮
    ohos:id="$+id:threadSleep"
        ohos:left_margin="24"
        ohos:width="match_content"
        ohos:height="match_content"
    ohos:text="$string:threadsleep"
    .../>
         ...    //线程无限循环按钮和死锁按钮同上
</DirectionalLayout>

setUIContent(ResourceTable.Layout_ability_main);//加载UI布局
final MyApplication application = (MyApplication) getAbilityPackage();//实例化

minAnrDurationButton.setClickedListener(new Component.ClickedListener() {
    @Override//重写onClick()方法
    public void onClick(Component component) {
        application.duration = application.duration % 6 + 2;//得到整除6的余数加2
        minAnrDurationButton.setText(application.duration + " seconds");
    }
});

reportModeButton.setClickedListener(new Component.ClickedListener() {
    @Override//重写onClick()方法
    public void onClick(Component component) {
        mode = (mode + 1) % 3;//得到mode加1并整除3后的余数
        switch (mode) {
            case 0:
                ...//所有线程
                application.anrWatchDog.setReportAllThreads();break ;
            case 1:
                ...//只有主线程
                application.anrWatchDog.setReportMainThreadOnly();break ;
            case 2:
                ...//过滤以“APP:”为前缀的线程
              application.anrWatchDog.setReportThreadNamePrefix("APP:");break ;
        }
    }
});

behaviourButton.setClickedListener(new Component.ClickedListener() {
    @Override//重写onClick()方法
    public void onClick(Component component) {
        crash = !crash;每次点击更改crash的布尔类型
        if (crash) {//crash为true
            behaviourButton.setText("Crash");
            application.anrWatchDog.setANRListener(null);//无需设置回调
        } else {//crash不为true
            behaviourButton.setText("Silent");//自定义ANRListener回调
           application.anrWatchDog.setANRListener(application.silentListener);
        }
    }

findComponentById(ResourceTable.Id_threadSleep).setClickedListener(new Component.ClickedListener() {//线程休眠Button的click点击事件
    @Override
    public void onClick(Component component) {//重写onClick()方法
        Sleep();//调用模拟线程休眠的函数
    }
});

//构造方法一
public ANRWatchDog() {
    this(DEFAULT_ANR_TIMEOUT);//使用默认的阻塞响应时间5000ms
}
//构造方法二
public ANRWatchDog(int timeoutInterval) {
    super();
    _timeoutInterval = timeoutInterval;//自定义阻塞响应时间timeoutInterval
}

private volatile long _tick = 0; //用于标志_ticker是否被处理
private volatile boolean _reported = false;
private final Runnable _ticker = new Runnable() {
    @Override public void run() {//_ticker处理线程
        _tick = 0;//重置为初始值0，表示_ticker被处理
        _reported = false;
    }
};

@Override
public void run() {//ANRWatchDog类的执行过程
    setName("|ANR-WatchDog|");
    long interval = _timeoutInterval;
    while (!isInterrupted()) {
        boolean needPost = _tick == 0;//将“_tick是初始值0”赋给needPost
        _tick += interval;//_tick值加一个阻塞响应时间
        if (needPost) {//判断_tick是否为0
            _uiHandler.postTask(_ticker);//发送_ticker给主线程
        }
...} 

try {
    Thread.sleep(interval);//ANRWatchDog线程休眠一个阻塞响应时间
} catch (InterruptedException e) {
    _interruptionListener.onInterrupted(e);
    return ;
}
if (_tick != 0 && !_reported) {//如果主线程没有处理_ticker，则主线程阻塞
    ...
    final ANRError error;//声明ANRError类
    if (_namePrefix != null) {//调用ANRError类的New()方法
            error = ANRError.New(_tick, _namePrefix, _logThreadsWithoutStackTrace);
    } else {//调用ANRError类NewMainOnly()方法
            error = ANRError.NewMainOnly(_tick);
    }
}

_anrListener.onAppNotResponding(error);  //响应行为设置

static ANRError NewMainOnly(long duration) {
    final Thread mainThread =  //通过getMainEventRunner()方法获取到主线程findThread(EventRunner.getMainEventRunner().getThreadId());
    //获取堆栈信息
    final StackTraceElement[] mainStackTrace = mainThread.getStackTrace();
    return new ANRError(new $(getThreadTitle(mainThread), mainStackTrace).new _Thread(null), duration);//返回重新构造的ANRError实例
}

static ANRError New(long duration, String prefix, boolean logThreadsWithoutStackTrace) {
    final Thread mainThread = //通过getMainEventRunner()方法获取到主线程findThread(EventRunner.getMainEventRunner().getThreadId());
    final Map<Thread, StackTraceElement[]> stackTraces = new TreeMap<Thread, StackTraceElement[]>(new Comparator<Thread>() {@Override...});//获取堆栈信息
    ...
    for (Map.Entry<Thread, StackTraceElement[]> entry : stackTraces.entrySet())
        tst = new $(getThreadTitle(entry.getKey()), entry.getValue()).new _Thread(tst);//重新构造ANRError实例
    return new ANRError(tst, duration);//返回重新构造的ANRError实例
}