（原创）手写一个ANR监控类ANRWatchDog

前言

实际APP开发中，因为主线程阻塞而导致的ANR是一个比较难定位的问题
今天自己写了一个ANR的监控类，用来监听项目中ANR发生的情况
源码后面会贴上来，下面我们进入介绍部分

使用

使用起来很简单
在我们的application里面这样配置即可：

        ANRWatchDog.getInstance().addANRListener(new ANRWatchDog.ANRListener() {
            @Override
            public void onAnrHappened(String stackTraceInfo) {
                //发生ANR时的回调监听，stackTraceInfo为堆栈信息
            }

            @Override
            public void onNotAnrHappened() {
                //未发生ANR
            }
        }).start();

原理介绍

下面是原理介绍部分
首先我们的这个工具类其实是一个单例的线程
可以看到使用的时候调用了start方法来开启线程
线程开启后，我们将线程设置为后台线程
然后进入一个while (true)的死循环
先获取一个当前时间，记录一个标志位
然后用handler往主线程发送一个Runnable消息
然后线程立马进入wait(5000)等待五秒
五秒后，如果没发生卡顿，我们的Runnable肯定就可以运行
然后把标志位改回来，表示未发现ANR即可
如果发生了卡顿，我们只需要通过判断标志位，就可以得知
这时候只需要打印堆栈信息
并且回调监听函数即可
当然，这里设置的默认ANR标准是五秒
我们也可以在工具类里面自己设置
另外，wait（5000）也会偶尔出现一个假唤醒的问题
就是线程被提前唤醒了，并没有真正等待五秒
这里我们也做了预防判断，如果没到五秒，就继续wait，代码如下：

源码

最后贴上全部的源码，方便大家使用：

public class ANRWatchDog extends Thread {

    private static final String TAG = "ANRWatchDog";
    private int timeout = 5000;
    private boolean ignoreDebugger = true;//debug模式下是否监听 true代表debug模式要监听，false代表不监听

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

    public interface ANRListener {
        void onAnrHappened(String stackTraceInfo);

        void onNotAnrHappened();
    }

    private ANRChecker anrChecker = new ANRChecker();

    private ANRListener anrListener;

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

    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()) {
                        if (anrListener != null) {
                            //没有ANR发生
                            anrListener.onNotAnrHappened();
                        }
                        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();
    }
}