Android性能优化—ANR问题分析

一、ANR是什么？

ANR(Application Not responding)，是指应用程序未响应，Android系统对于一些事件需要在一定的时间范围内完成，如果超过预定时间能未能得到有效响应或者响应时间过长，都会造成ANR。可以简单的理解为应用程序在UI线程被阻塞太长时间，就会出现ANR。

通常出现ANR，系统会弹出一个提示提示框，让用户知道，该程序正在被阻塞，是否继续等待还是关闭。 

二、ANR的类型：

1. KeyDispatchTimeout（常见）

1.1 input事件在5S内没有处理完成发生了ANR。
1.2 logcat日志关键字：Input event dispatching timed out

2. BroadcastTimeout

2.1 前台Broadcast：onReceiver在10S内没有处理完成发生ANR。
2.2 后台Broadcast：onReceiver在60s内没有处理完成发生ANR。
2.3 logcat日志关键字：Timeout of broadcast BroadcastRecord

3. ServiceTimeout

3.1 前台Service：onCreate，onStart，onBind等生命周期在20s内没有处理完成发生ANR。
3.2 后台Service：onCreate，onStart，onBind等生命周期在200s内没有处理完成发生ANR
3.3 logcat日志关键字：Timeout executing service

4. ContentProviderTimeout

4.1 ContentProvider 在10S内没有处理完成发生ANR。 
4.2 logcat日志关键字：timeout publishing content providers 

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

三、为什么会出现ANR？

1: 主线程频繁进行耗时的IO操作：如数据库读写；

2: 多线程操作的死锁，主线程被block；held by；

3: 主线程被Binder 对端block；

4: System Server中WatchDog出现ANR；

5: service binder的连接达到上线无法和和System Server通信；

6: 系统资源已耗尽（管道、CPU、IO）。

四、如何避免 ANR？

1.运行在主线程里的方法尽可能少做事情，特别是Activity的关键生命周期方法（如 onCreate()和 onResume()）里尽可能少的去做创建操作。潜在的耗时操作，例如网络或数据库操作，或者高耗时的计算如改变位图尺寸，应该在子线程里（或者以数据 库操作为例，通过异步请求的方式）来完成。

2.避免在 BroadcastReceiver 里做耗时的操作或计算。但也不能在BroadcastReceiver开启子线程来做这些任务（因为BroadcastReceiver 的生命周期短），替代的是，如果响应 Intent 广播需要执行一个耗时的动作的话，应用程序应该启动一个 Service。

3.增强响应灵敏性，应用程序为响应用户输入正在后台工作的话，可以显示工作的进度ProgressBar和 ProgressDialog，让用户感知你的应用在工作，让你的应用程序看起来有响应性。

总结：

1）主线程尽量只做UI相关的操作,避免耗时操作，比如过度复杂的UI绘制，网络操作，文件IO操作；

2）避免主线程跟工作线程发生锁的竞争，减少系统耗时binder的调用，谨慎使sharePreference，注意主线程执行provider query操作；

3）尽可能减少主线程的负载，让其空闲待命，以期可随时响应用户的操作。 

五、ANR问题如何解决？ 

1、ANR发生后，Android系统会执行以下操作，去抓取现场的信息:

1. 将am_anr信息输出到EventLog，也就是说ANR触发的时间点最接近的就是EventLog中输出的am_anr信息；

2. 收集以下重要进程的各个线程调用栈trace信息，保存在data/anr/traces.txt文件，包含：

  1) 当前发生ANR的进程，system_server进程以及所有persistent进程；
  2) audioserver, cameraserver, mediaserver, surfaceflinger等重要的native进程；
  3) CPU使用率排名前5的进程；

3. 将发生ANR的reason以及CPU使用情况信息输出到main log；

4. 将traces文件和CPU使用情况信息保存到dropbox，即data/system/dropbox目录；

5. 对用户可感知的进程则弹出ANR对话框告知用户，对用户不可感知的进程发生ANR则直接杀掉。

2、分析步骤

1. 定位发生ANR时间点；

2. 查看trace信息；

3. 分析是否有耗时的message,binder调用，锁的竞争，CPU资源的抢占；

4. 结合具体的业务场景的上下文来分析；

3、分析技巧

1. 通过logcat日志，traces文件确认anr发生时间点；

2. 查看traces文件和CPU使用率，/data/anr/traces.txt；

3. 查看主线程状态和其他线程状态；

4. 查看关键信息：
    ANR时间：07-20 15:36:36.472
    进程pid：1480
    进程名：com.xxxx.moblie
    ANR类型：KeyDispatchTimeout

实战案例：http://t.csdn.cn/KIrn2

六、ANR监控方案：

1、自定义watchdog 

1. WatchDog实现流程

 

2. 参考WatchDog，自定义ANRWatchDog：

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

2、FileObserver 

Android系统在此基础上封装了一个FileObserver类来方便使用Inotify机制。FileObserver是一个抽象类，需要定义子类实现该类的onEvent抽象方法，当被监控的文件或者目录发生变更事件时，将回调FileObserver的onEvent()函数来处理文件或目录的变更事件。 

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