Android 性能优化入门（三）—— ANR 问题分析

tmacfrank2025-05-26 14:34

需要清楚 ANR 的概念、类型、如何产生以及如何定位分析。

1、概述

1.1 ANR 的概念

ANR（Application Not Responding）应用程序无响应。如果你应用程序在主线程被阻塞太长时间，就会出现 ANR，通常出现 ANR，系统会弹出一个提示框，让用户知道，该程序正在被阻塞，是否继续等待还是关闭。

1.2 ANR 类型

ANR 有 4 种类型：

  1. KeyDispatchTimeout（常见）：Input 事件在 5 秒内没有处理完成导致发生 ANR
    • logcat 日志关键字：Input event dispatching timed out
  2. BroadcastTimeout：前台 BroadcastReceiver 的 onReceive() 在 10 秒内没有处理完成、后台 BroadcastReceiver 的 onReceive() 在 60 秒内没有处理完成会发生 ANR
    • logcat 日志关键字：Timeout of broadcast BroadcastRecord
  3. ServiceTimeout：前台 Service 的 onCreate、onStart、onBind 等生命周期方法在 20 秒内没有处理完成，后台 Service 的onCreate、onStart、onBind 等生命周期方法在 200 秒内没有处理完成会发生 ANR
    • logcat 日志关键字：Timeout executing service
  4. ContentProviderTimeout：ContentProvider 在 10 秒内没有处理完成发生 ANR。
    • logcat日志关键字：timeout publishing content providers

注意，KeyDispatchTimeout 与其他机制不同。对于 Input 来说，即便某次事件的执行时间超过 5 秒，只要用户后续没有再生成新的 Input 事件，就不会触发 ANR。

1.3 ANR 出现的原因

原因主要有以下几种：

  1. 主线程频繁进行耗时的 IO 操作：如数据库读写
  2. 多线程操作的死锁，主线程被 block
  3. 主线程被 Binder 对端 block
  4. System Server 中 WatchDog 出现 ANR
  5. Service binder 的连接达到上限无法和 System Server 通信
  6. 系统资源已耗尽（管道、CPU、IO）

凡是进行 IO 读写的操作，都不要放在主线程中，SharedPreferences 也涉及 IO 操作，也包含在内。此外，网络、序列化也不要放在主线程中。

多核 CPU 的执行效率不一样，以八核为例，一般 0~3 是小核，4~5 是中核，6~7 是大核，手机厂商在游戏模式中会将游戏绑定到大核上运行。

2、ANR 问题的解决

线下的 ANR 问题，有 3 个 log 文件可以寻找相关信息：

  1. /data/anr/trace_*.txt：一般 firstPid 就是发生 ANR 的 pid。主要是在 ActivityManagerservice 中通过 appNotResponding()、dumpStackTraces() 来生成应用的 ANR
  2. traces_SystemServer_WDT.txt：WatchDog 中实现，会打印 system_server 进程栈信息
  3. traces.txt：dalvik.vm.stack-trace-file，是系统定义的默认 trace 文件路径

线上的 ANR 问题，一般只能通过 Bugly 提供信息，而且信息还有可能不全，因此线上 ANR 是很不好解决的。

2.1 分析技巧

ANR 问题除了特别明显的那种，一般都不是一眼就能看出来问题点的，需要多个角度分析。

分析技巧主要有以下几点：

  1. 通过 logcat 日志，traces 文件确认 ANR 发生时间点
  2. traces 文件和 CPU 使用率
  3. /data/anr/traces.txt
  4. 主线程状态
  5. 其他线程状态

2.2 关键信息

关键信息1：

ANR时间：07-20 15:36:36.472

进程pid：1480

进程名：com.xxxx.moblie

ANR类型：KeyDispatchTimeout

关键信息2：

main：main标识是主线程，如果是线程，那么命名成"Thread-X"的格式,x表示线程id,逐步递增。

prio：线程优先级,默认是5

tid：tid不是线程的id，是线程唯一标识ID

group：是线程组名称

sCount：该线程被挂起的次数

dsCount：是线程被调试器挂起的次数

obj：对象地址

self：该线程Native的地址

sysTid：是线程号(主线程的线程号和进程号相同)

nice：是线程的调度优先级

sched：分别标志了线程的调度策略和优先级

cgrp：调度归属组

handle：线程处理函数的地址。

state：是调度状态

schedstat：从 /proc/[pid]/task/[tid]/schedstat读出，三个值分别表示线程在cpu上执行的时间、线程的等待时间和线程执行的时间片长度，不支持这项信息的三个值都是0；

utm：是线程用户态下使用的时间值(单位是jiffies）

stm：是内核态下的调度时间值

core：是最后执行这个线程的cpu核的序号

线程状态：

THREAD_UNDEFINED = -1

THREAD_ZOMBIE = 0, /* TERMINATED /
THREAD_RUNNING = 1, / RUNNABLE or running now /
THREAD_TIMED_WAIT = 2,/ TIMED_WAITING Object.wait()

THREAD_MONITOR = 3, /* BLOCKED on a monitor /
THREAD_WAIT = 4, / WAITING in Object.wait() /
THREAD_INITIALIZING= 5, / allocated, not yet running /
THREAD_STARTING = 6, / started, not yet on thread list /
THREAD_NATIVE = 7, / off in a JNI native method /
THREAD_VMWAIT = 8, / waiting on a VM resource /
THREAD_SUSPENDED = 9, / suspended, usually by GC or debugger

3、ANR 线上监控方案

两种方案，原生的可以通过 FileObserver，也可以通过 WatchDog。

3.1 FileObserver

FileObserver 可以监控某个目录/文件的状态发生改变、创建或删除文件，可以监听 /data/anr/ 目录下的文件变化。这样在发生变化时可以上传所有 ANR 的信息到服务器上，但是有可能是其他应用发生的 ANR。示例代码：

java 复制代码 
public class ANRFileObserver extends FileObserver {

    public ANRFileObserver(String path) {//data/anr/
        super(path);
    }

    public ANRFileObserver(String path, int mask) {
        super(path, mask);
    }

    @Override
    public void onEvent(int event, @Nullable String path) {
        switch (event) {
			case FileObserver.ACCESS://文件被访问
				Log.i("Zero", "ACCESS: " + path);
				break;
			case FileObserver.ATTRIB://文件属性被修改，如 chmod、chown、touch 等
				Log.i("Zero", "ATTRIB: " + path);
				break;
			case FileObserver.CLOSE_NOWRITE://不可写文件被 close
				Log.i("Zero", "CLOSE_NOWRITE: " + path);
				break;
			case FileObserver.CLOSE_WRITE://可写文件被 close
				Log.i("Zero", "CLOSE_WRITE: " + path);
				break;
			case FileObserver.CREATE://创建新文件
				Log.i("Zero", "CREATE: " + path);
				break;
			case FileObserver.DELETE:// 文件被删除，如 rm
				Log.i("Zero", "DELETE: " + path);
				break;
			case FileObserver.DELETE_SELF:// 自删除，即一个可执行文件在执行时删除自己
				Log.i("Zero", "DELETE_SELF: " + path);
				break;
			case FileObserver.MODIFY://文件被修改
				Log.i("Zero", "MODIFY: " + path);
				break;
			case FileObserver.MOVE_SELF://自移动，即一个可执行文件在执行时移动自己
				Log.i("Zero", "MOVE_SELF: " + path);
				break;
			case FileObserver.MOVED_FROM://文件被移走，如 mv
				Log.i("Zero", "MOVED_FROM: " + path);
				break;
			case FileObserver.MOVED_TO://文件被移来，如 mv、cp
				Log.i("Zero", "MOVED_TO: " + path);
				break;
			case FileObserver.OPEN://文件被 open
				Log.i("Zero", "OPEN: " + path);
				break;
			default:
				//CLOSE ： 文件被关闭，等同于(IN_CLOSE_WRITE | IN_CLOSE_NOWRITE)
				//ALL_EVENTS ： 包括上面的所有事件
				Log.i("Zero", "DEFAULT(" + event + "): " + path);
				break;
        }
    }
}

FileObserver 在 5.0 的系统以上会受到 SELinux 的限制，手机厂商可以通过修改 .te 的配置文件规避掉这个限制。

3.2 WatchDog

WatchDog 是一个单例线程，在 Android 中主要用来检查 system_server 进程有没有死锁，或者某些线程有没有被卡住。其内部类 HandlerChecker 把自己加到 Handler 中：

java 复制代码 
    public final class HandlerChecker implements Runnable {
        
        private final Handler mHandler;
        
        public void scheduleCheckLocked() {
            if (mMonitors.size() == 0 && mHandler.getLooper().getQueue().isPolling()) {
                mCompleted = true;
                return;
            }

            if (!mCompleted) {
                // we already have a check in flight, so no need
                return;
            }

            mCompleted = false;
            mCurrentMonitor = null;
            mStartTime = SystemClock.uptimeMillis();
            // 将自己加入到 Handler 中
            mHandler.postAtFrontOfQueue(this);
        }
        
        @Override
        public void run() {
            final int size = mMonitors.size();
            for (int i = 0 ; i < size ; i++) {
                synchronized (Watchdog.this) {
                    mCurrentMonitor = mMonitors.get(i);
                }
                mCurrentMonitor.monitor();
            }

            synchronized (Watchdog.this) {
                mCompleted = true;
                mCurrentMonitor = null;
            }
        }
    }

WatchDog 会持续运行，检查 HandlerChecker 中的 run() 有没有被执行：

java 复制代码 
    @Override
    public void run() {
        boolean waitedHalf = false;
        while (true) {
            final List<HandlerChecker> blockedCheckers;
            final String subject;
            final boolean allowRestart;
            int debuggerWasConnected = 0;
            synchronized (this) {
                long timeout = CHECK_INTERVAL;
                // Make sure we (re)spin the checkers that have become idle within
                // this wait-and-check interval
                for (int i=0; i<mHandlerCheckers.size(); i++) {
                    HandlerChecker hc = mHandlerCheckers.get(i);
                    hc.scheduleCheckLocked();
                }

                if (debuggerWasConnected > 0) {
                    debuggerWasConnected--;
                }

                
                long start = SystemClock.uptimeMillis();
                while (timeout > 0) {
                    if (Debug.isDebuggerConnected()) {
                        debuggerWasConnected = 2;
                    }
                    try {
                        wait(timeout);
                    } catch (InterruptedException e) {
                        Log.wtf(TAG, e);
                    }
                    if (Debug.isDebuggerConnected()) {
                        debuggerWasConnected = 2;
                    }
                    timeout = CHECK_INTERVAL - (SystemClock.uptimeMillis() - start);
                }

                boolean fdLimitTriggered = false;
                if (mOpenFdMonitor != null) {
                    fdLimitTriggered = mOpenFdMonitor.monitor();
                }

                if (!fdLimitTriggered) {
                    final int waitState = evaluateCheckerCompletionLocked();
                    if (waitState == COMPLETED) {
                        // The monitors have returned; reset
                        waitedHalf = false;
                        continue;
                    } else if (waitState == WAITING) {
                        // still waiting but within their configured intervals; back off and recheck
                        continue;
                    } else if (waitState == WAITED_HALF) {
                        if (!waitedHalf) {
                            // We've waited half the deadlock-detection interval.  Pull a stack
                            // trace and wait another half.
                            ArrayList<Integer> pids = new ArrayList<Integer>();
                            pids.add(Process.myPid());
                            // 如果任务没执行，生成 trace 文件
                            ActivityManagerService.dumpStackTraces(true, pids, null, null,
                                getInterestingNativePids());
                            waitedHalf = true;
                        }
                        continue;
                    }

                    // something is overdue!
                    blockedCheckers = getBlockedCheckersLocked();
                    subject = describeCheckersLocked(blockedCheckers);
                } else {
                    blockedCheckers = Collections.emptyList();
                    subject = "Open FD high water mark reached";
                }
                allowRestart = mAllowRestart;

                ...
            }
        }
    }

我们可以借鉴 WatchDog 的原理自己检测：

代码如下：

java 复制代码 
public class ANRWatchDog extends Thread {

    private static final String TAG = "ANR";
    private int timeout = 5000;
    private boolean ignoreDebugger = true;

    static ANRWatchDog sWatchdog;

    private Handler mainHandler = new Handler(Looper.getMainLooper());


    private class ANRChecker implements Runnable {

        private boolean mCompleted;
        private long mStartTime;
        private long executeTime = SystemClock.uptimeMillis();

        @Override
        public void run() {
            synchronized (ANRWatchDog.this) {
                mCompleted = true;
                executeTime = SystemClock.uptimeMillis();
            }
        }

        void schedule() {
            mCompleted = false;
            mStartTime = SystemClock.uptimeMillis();
            mainHandler.postAtFrontOfQueue(this);
        }

        boolean isBlocked() {
            return !mCompleted || executeTime - mStartTime >= 5000;
        }
    }

    public interface ANRListener {
        void onAnrHappened(String stackTraceInfo);
    }

    private ANRChecker anrChecker = new ANRChecker();

    private ANRListener anrListener;

    public void addANRListener(ANRListener listener){
        this.anrListener = listener;
    }

    public static ANRWatchDog getInstance(){
        if(sWatchdog == null){
            sWatchdog = new ANRWatchDog();
        }
        return sWatchdog;
    }

    private ANRWatchDog(){
        super("ANR-WatchDog-Thread");
    }

    @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
    @Override
    public void run() {
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND); // 设置为后台线程
        while(true){
            while (!isInterrupted()) {
                synchronized (this) {
                    anrChecker.schedule();
                    long waitTime = timeout;
                    long start = SystemClock.uptimeMillis();
                    // 预防假唤醒（概率很低），从源码借鉴来的
                    while (waitTime > 0) {
                        try {
                            wait(waitTime);
                        } catch (InterruptedException e) {
                            Log.w(TAG, e.toString());
                        }
                        waitTime = timeout - (SystemClock.uptimeMillis() - start);
                    }
                    if (!anrChecker.isBlocked()) {
                        continue;
                    }
                }
                if (!ignoreDebugger && Debug.isDebuggerConnected()) {
                    continue;
                }
                String stackTraceInfo = getStackTraceInfo();
                if (anrListener != null) {
                    anrListener.onAnrHappened(stackTraceInfo);
                }
            }
            anrListener = null;
        }
    }

    private String getStackTraceInfo() {
        StringBuilder stringBuilder = new StringBuilder();
        for (StackTraceElement stackTraceElement : Looper.getMainLooper().getThread().getStackTrace()) {
            stringBuilder
                    .append(stackTraceElement.toString())
                    .append("\r\n");
        }
        return stringBuilder.toString();
    }
}

WatchDog 会有性能损耗。

相关推荐
hsx6661 小时前
Android 内存泄漏避坑
android
whysqwhw1 小时前
OkHttp之okhttp-bom模块的分析
android
餐桌上的王子1 小时前
Android 构建可管理生命周期的应用（二）
android
幽你一默2 小时前
Android 版本差异速查表（开发者视角）
android
不萌2 小时前
android 项目中的屏幕适配方案
android
幽你一默2 小时前
Android开发三分钟读懂mvc，mvp，mvvm，mvi
android
小仙女喂得猪3 小时前
2025 源码应用: Retrofit之动态更换BaseUrl
android·android studio
代码老y4 小时前
Spring Boot项目中大文件上传的高级实践与性能优化
spring boot·后端·性能优化
AmazingMQ4 小时前
Android 13----在framworks层映射一个物理按键
android
小李飞飞砖4 小时前
Android 插件化实现原理详解
android
热门推荐
01使用Ruby接入实时行情API教程02KGG转MP3工具|非KGM文件|解密音频03Coze扣子平台完整体验和实践（附国内和国际版对比）04深度神经网络训练过程与常见概念05集群聊天服务器---MySQL数据库的建立06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07【无标题】08Java学习第十五部分——MyBatis09DeepSeek各版本说明与优缺点分析10LOT: 通过逻辑增强大型语言模型的零样本Chain-of-Thought推理能力