当前位置：首页 > article >正文

如何应对 Android 面试官 -＞ ANR 如何优化？线上 ANR 如何监控？

article 2024/10/27 14:09:36

前言

在这里插入图片描述

本章主要围绕 ANR 如何监控以及优化；

基本概念

ANR(Android Not Responding) 是指应用程序未响应，Android 系统对于一些事件需要在一定的时间范围内完成，如果超过预订时间未能得到有效响应或者响应时间过长，都会造成 ANR。

ANR 常见类型

input 事件

input事件在5s内没有处理完；

logcat关键字：input event dispatching timed out；
tag：对于input来说，即便某次事件执行时长超过了timeout时长，只要后续没有再生成输入事件，则不会发生anr；

Input 的超时机制与其他不同，对于 input 事件来说即便某次事件执行时间超过了 timeout 时长，只要用户后续再没有生成输入事件，则不会触发 ANR；

broadcast事件

前台广播：10s内没有处理完；
后台广播：60s内没有处理完；

logcat关键字：timeout of broadcast BroadcastRecord

service事件

前台service：20s内没有处理完；
后台service：200s内没有处理完；

logcat关键字：timeout executing service；

provider 事件

10s内没有处理完；

logcat关键字：timeout publishing content provider；

ANR 出现的原因

主线程进行耗时的 IO 操作；
- 例如数据库读写
- 网络操作
- 序列化
- 文件读写
- sp 操作
多线程操作的死锁，导致主线程被block；
- traces.txt中的关键字：held mutexes / held by
系统资源被耗尽（管道 CPU IO）；
主线程被 binder，对端 block；
- binder 通信默认是同步的，也可以异步实现，如果同步通信的时候，如果对端被 block 之后，导致主端就会无限等待；
System Server 中的 WatchDog 出现 anr；
Service binder 的连接达到上限，无法和 System Server 通信；

ANR 问题如何解决

发生 anr 之后会在 /data/anr/trace_*.txt 生成这么一个文件；

如何分析这个 trace 文件；

发生 anr 之后，一般是 firstPid，即发生 anr 的 Pid；
线下发生 anr 的时候，通过 logcat 日志，traces 文件确认 anr 发生时间点，traces 文件和 cpu 使用率；
traces 文件分析
- ANR 时间
- 当前应用进程 id
- 当前应用的进程名
- ANR类型：KeyDispatchTimeout
- held by、mutexes 关键字
- 关注线程状态

ANR 如何进行线上监控的原理

FileObserver

Android 系统提供了一个抽象类 FileObserver，我们可以通过它来监控 data/anr/traces_xxx.txt 文件的变化，用来监控某个目录/文件状态发生改变，有没有创建或者删除文件；

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

ANR WatchDog

系统源码中『看门狗』的实现：监控 System Server 中的 AMS 有没有死锁，某个线程有没有被卡住；

在这里插入图片描述

参考 Watchdog 的监控方案；

在这里插入图片描述

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();
    }
}

查看全文

http://www.kler.cn/news/367359.html