Android Watchdog

1、Watchdog，是什么?

从代码上看，Watchdog，是一个线程，因为他是继承Thread类。
从功能上看，Watchdog就像它的名字一样，看门狗，功能是检测一些重要的系统服务（service）和线程（Thread）是否正常工作。

2、 Watchdog是如何工作的？

想要了解Watchdog是如何工作的，先要了解它的内部类HandlerChecker和一些重要的方法。

HandlerChecker实现了Runnable，他有一个重要的方法

 public void scheduleCheckLocked() {
            //判断Looper是否在轮询，如果是的话，就置状态为Completed(这个是用来判断，Thread.Looper是否能及时处理消息)
            if (mMonitors.size() == 0 && mHandler.getLooper().isIdling()) {
                mCompleted = true;
                return;
            }

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

            mCompleted = false;
            mCurrentMonitor = null;
            mStartTime = SystemClock.uptimeMillis();
            //如果上面的第一判断不通过，也就是说：isIdling()为false，这个时候，我们调用mHandler.postAtFrontOfQueue(this);那么我们这个消息会在前面那个执行之后再执行，这样就可以判断，前面那个消息的处理占用了多少时间。
            mHandler.postAtFrontOfQueue(this);
        }

作为一个Runnable，他还有一个重要方法就是：run方法

 public void run() {
            final int size = mMonitors.size();
            //这里主要是调用Monitor的monitor方法
            for (int i = 0 ; i < size ; i++) {
                synchronized (Watchdog.this) {
                    mCurrentMonitor = mMonitors.get(i);
                }
                mCurrentMonitor.monitor();
            }

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

了解了HandlerChecker之后，就是Watchdog是如何工作的。首先是构造方法：

//构造函数是private，最终可以看到Watchdog是一个singleton
private Watchdog() {
        super("watchdog");
        //实例化一个HandlerChecker,Handler是前台线程的Handler，其实就是检测前台线程的Looper是否能及时处理消息，同时对UI/IO/Main线程进行检测
        mMonitorChecker = new HandlerChecker(FgThread.getHandler(),
                "foreground thread", DEFAULT_TIMEOUT);
        mHandlerCheckers.add(mMonitorChecker);
        mHandlerCheckers.add(new HandlerChecker(new Handler(Looper.getMainLooper()),
                "main thread", DEFAULT_TIMEOUT));
        mHandlerCheckers.add(new HandlerChecker(UiThread.getHandler(),
                "ui thread", DEFAULT_TIMEOUT));
        mHandlerCheckers.add(new HandlerChecker(IoThread.getHandler(),
                "i/o thread", DEFAULT_TIMEOUT));
        mHandlerCheckers.add(new HandlerChecker(DisplayThread.getHandler(),
                "display thread", DEFAULT_TIMEOUT));
        exceptionHWT = new ExceptionLog();
    }

然后就是Watchdog的run()方法：这里讲将打印Log和重启的代码删了，因为我们主要了解工作过程。

public void run() {
        boolean waitedHalf = false;
        while (true) {
            final ArrayList<HandlerChecker> blockedCheckers;
            final String subject;
            final boolean allowRestart;
            int debuggerWasConnected = 0;
            if(exceptionHWT!= null){
                exceptionHWT.WDTMatterJava(300);
            }

            synchronized (this) {
                long timeout = CHECK_INTERVAL;
                //遍历在构造方法中初始化的HandlerChecker的scheduleCheckLocked
                for (int i=0; i<mHandlerCheckers.size(); i++) {
                    HandlerChecker hc = mHandlerCheckers.get(i);
                    hc.scheduleCheckLocked();
                }
                long start = SystemClock.uptimeMillis();
                while (timeout > 0) {
                    try {
                        wait(timeout);
                    } catch (InterruptedException e) {
                        Log.wtf(TAG, e);
                    }
                    timeout = CHECK_INTERVAL - (SystemClock.uptimeMillis() - start);
                }

                final int waitState = evaluateCheckerCompletionLocked();
                if (waitState == COMPLETED) {
                    // 顺利完成，没有阻塞
                    waitedHalf = false;
                    continue;
                } else if (waitState == WAITING) {
                    continue;
                } else if (waitState == WAITED_HALF) {
                    if (!waitedHalf) {
                        ArrayList<Integer> pids = new ArrayList<Integer>();
                        pids.add(Process.myPid());
                        ActivityManagerService.dumpStackTraces(true, pids, null, null,NATIVE_STACKS_OF_INTEREST);
                        waitedHalf = true;
                    }
                    continue;
                }

                // something is overdue!
                blockedCheckers = getBlockedCheckersLocked();
                subject = describeCheckersLocked(blockedCheckers);
                allowRestart = mAllowRestart;
            }
    }

Watchdog的整个过程是：初始化（添加需要检测的线程）->run()调用HandlerChecker.scheduleCheckLocked去检测->evaluateCheckerCompletionLocked()判断状态。