Android中SystemServer的Watchdog

 private void startOtherServices() {
            ....
            // 在SystemServer进程中初始化Watchdog单例
            traceBeginAndSlog("InitWatchdog");
            final Watchdog watchdog = Watchdog.getInstance();
            watchdog.init(context, mActivityManagerService);
            traceEnd();
            // 初始化InputManagerService
            traceBeginAndSlog("StartInputManagerService");
            inputManager = new InputManagerService(context);
            traceEnd();
            ....

             mActivityManagerService.systemReady(() -> {
                    ...
                    // 启动Watchdog线程开始监控
                    traceBeginAndSlog("StartWatchdog");
                    Watchdog.getInstance().start();
                    traceEnd();
                    ...
            }
}

public class Watchdog extends Thread {
    // 超时时间
    static final long DEFAULT_TIMEOUT = DB ? 10*1000 : 60*1000;
    // 检测周期
    static final long CHECK_INTERVAL = DEFAULT_TIMEOUT / 2;
  
private Watchdog() {
        super("watchdog");
        mMonitorChecker = new HandlerChecker(FgThread.getHandler(),
                "foreground thread", DEFAULT_TIMEOUT);
        mHandlerCheckers.add(mMonitorChecker);
        // 检测主线程 , 以及默认检测时间为60S
        mHandlerCheckers.add(new HandlerChecker(new Handler(Looper.getMainLooper()),
                "main thread", DEFAULT_TIMEOUT));
        // 检测UI线程
        mHandlerCheckers.add(new HandlerChecker(UiThread.getHandler(),
                "ui thread", DEFAULT_TIMEOUT));
        // 检测IO线程
        mHandlerCheckers.add(new HandlerChecker(IoThread.getHandler(),
                "i/o thread", DEFAULT_TIMEOUT));
        // 检测Display线程
        mHandlerCheckers.add(new HandlerChecker(DisplayThread.getHandler(),
                "display thread", DEFAULT_TIMEOUT));
        // 检测Binder线程
        addMonitor(new BinderThreadMonitor());
    }

    public void init(Context context, ActivityManagerService activity) {
        mResolver = context.getContentResolver();
        mActivity = activity;
        // 初始化Reboot广播
        context.registerReceiver(new RebootRequestReceiver(),
                new IntentFilter(Intent.ACTION_REBOOT),
                android.Manifest.permission.REBOOT, null);
    }
}

@Override
    public void run() {
        boolean waitedHalf = false;
        while (true) {
            final ArrayList<HandlerChecker> blockedCheckers;
            final String subject;
            final boolean allowRestart;
            int debuggerWasConnected = 0;
            synchronized (this) {
                // 检测超时时间
                long timeout = CHECK_INTERVAL;
                // 检测HandlerChekcer是否处于Idle状态
                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);
                }
                // 计算所有Checker的检测状态
                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
                    // 如果处于Waiting状态
                    continue;
                } else if (waitState == WAITED_HALF) {
                    // 如果有一部分处于Wait状态
                    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());
                        ActivityManagerService.dumpStackTraces(true, pids, null, null,
                            getInterestingNativePids());
                        waitedHalf = true;
                    }
                    continue;
                }
                blockedCheckers = getBlockedCheckersLocked();
                subject = describeCheckersLocked(blockedCheckers);
                allowRestart = mAllowRestart;
            }
            EventLog.writeEvent(EventLogTags.WATCHDOG, subject);
            // 如果能执行到这里 ,代表系统已经hung住 , 也就是阻塞住了 , 
            // 就开始收集Thread的Stack Traces从系统的所有线程里 , 然后重启
            ArrayList<Integer> pids = new ArrayList<>();
            pids.add(Process.myPid());
            if (mPhonePid > 0) pids.add(mPhonePid);
            // Pass !waitedHalf so that just in case we somehow wind up here without having
            // dumped the halfway stacks, we properly re-initialize the trace file.
            final File stack = ActivityManagerService.dumpStackTraces(
                    !waitedHalf, pids, null, null, getInterestingNativePids());

            // Give some extra time to make sure the stack traces get written.
            // The system's been hanging for a minute, another second or two won't hurt much.
            SystemClock.sleep(2000);

            // Pull our own kernel thread stacks as well if we're configured for that
            if (RECORD_KERNEL_THREADS) {
                dumpKernelStackTraces();
            }

            // Trigger the kernel to dump all blocked threads, and backtraces on all CPUs to the kernel log
            doSysRq('w');
            doSysRq('l');

            // Try to add the error to the dropbox, but assuming that the ActivityManager
            // itself may be deadlocked.  (which has happened, causing this statement to
            // deadlock and the watchdog as a whole to be ineffective)
            Thread dropboxThread = new Thread("watchdogWriteToDropbox") {
                    public void run() {
                        mActivity.addErrorToDropBox(
                                "watchdog", null, "system_server", null, null,
                                subject, null, stack, null);
                    }
                };
            dropboxThread.start();
            try {
                dropboxThread.join(2000);  // wait up to 2 seconds for it to return.
            } catch (InterruptedException ignored) {}

            IActivityController controller;
            synchronized (this) {
                controller = mController;
            }
            if (controller != null) {
                Slog.i(TAG, "Reporting stuck state to activity controller");
                try {
                    Binder.setDumpDisabled("Service dumps disabled due to hung system process.");
                    // 1 = keep waiting, -1 = kill system
                    int res = controller.systemNotResponding(subject);
                    if (res >= 0) {
                        Slog.i(TAG, "Activity controller requested to coninue to wait");
                        waitedHalf = false;
                        continue;
                    }
                } catch (RemoteException e) {
                }
            }

            // Only kill the process if the debugger is not attached.
            if (Debug.isDebuggerConnected()) {
                debuggerWasConnected = 2;
            }
            if (debuggerWasConnected >= 2) {
                Slog.w(TAG, "Debugger connected: Watchdog is *not* killing the system process");
            } else if (debuggerWasConnected > 0) {
                Slog.w(TAG, "Debugger was connected: Watchdog is *not* killing the system process");
            } else if (!allowRestart) {
                Slog.w(TAG, "Restart not allowed: Watchdog is *not* killing the system process");
            } else {
                Slog.w(TAG, "*** WATCHDOG KILLING SYSTEM PROCESS: " + subject);
                for (int i=0; i<blockedCheckers.size(); i++) {
                    Slog.w(TAG, blockedCheckers.get(i).getName() + " stack trace:");
                    StackTraceElement[] stackTrace
                            = blockedCheckers.get(i).getThread().getStackTrace();
                    for (StackTraceElement element: stackTrace) {
                        Slog.w(TAG, "    at " + element);
                    }
                }
                Slog.w(TAG, "*** GOODBYE!");
                Process.killProcess(Process.myPid());
                System.exit(10);
            }
            waitedHalf = false;
        }
    }

private int evaluateCheckerCompletionLocked() {
        int state = COMPLETED;
        for (int i=0; i<mHandlerCheckers.size(); i++) {
            HandlerChecker hc = mHandlerCheckers.get(i);
            state = Math.max(state, hc.getCompletionStateLocked());
        }
        return state;
    }

 public int getCompletionStateLocked() {
            // 如果当前状态为完成 , 则返回COMPLETED
            if (mCompleted) {
                return COMPLETED;
            } else {
                // 计算延迟
                long latency = SystemClock.uptimeMillis() - mStartTime;
                // 如果延迟时间小于DEFAULT_TIMEOUT的一半 , 则返回等待状态
                if (latency < mWaitMax/2) {
                    return WAITING;
                // 如果延迟时间大于DEFAULT_TIMEOUT的一半并且小于等待时间
                } else if (latency < mWaitMax) {
                    return WAITED_HALF;
                }
            }
            // 如果超过等待时间 , 则返回OVERDUE代表超时了
            return OVERDUE;
        }

public final class IoThread extends ServiceThread {
    private static IoThread sInstance;
    private static Handler sHandler;

    private IoThread() {
        super("android.io", android.os.Process.THREAD_PRIORITY_DEFAULT, true /*allowIo*/);
    }

    private static void ensureThreadLocked() {
        if (sInstance == null) {
            // 启动IOThread线程
            sInstance = new IoThread();
            sInstance.start();
            sInstance.getLooper().setTraceTag(Trace.TRACE_TAG_ACTIVITY_MANAGER);          // 初始化IOThread的Looper队列
            sHandler = new Handler(sInstance.getLooper());
        }
    }

    public static IoThread get() {
        synchronized (IoThread.class) {
            ensureThreadLocked();
            return sInstance;
        }
    }

    public static Handler getHandler() {
        synchronized (IoThread.class) {
            ensureThreadLocked();
            return sHandler;
        }
    }
}

private void writeSessionsAsync() {
        IoThread.getHandler().post(new Runnable() {
            @Override
            public void run() {
                synchronized (mSessions) {
                    writeSessionsLocked();
                }
            }
        });
    }

public void scheduleCheckLocked() {
            if (mMonitors.size() == 0 && mHandler.getLooper().getQueue().isPolling()) {
                // 如果monitor为空 , 并且处于Polling状态时 , 返回完成状态
                mCompleted = true;
                return;
            }

            if (!mCompleted) {
                // 如果还未检查完毕 ,  就直接返回
                return;
            }
            // 如果需要检测死锁的话 , 就将starttime记录 , 并且将自身放入对应Looper中
            mCompleted = false;
            mCurrentMonitor = null;
            mStartTime = SystemClock.uptimeMillis();
            // 将HandlerChecker post到对应线程中进行检测
            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);
                }
                // 调用Monitor.monitor
                mCurrentMonitor.monitor();
            }

            synchronized (Watchdog.this) {
                // 标示检测完成
                mCompleted = true;
                mCurrentMonitor = null;
            }
        }

@Override
public void monitor() {
      synchronized (mInputFilterLock) { }
       nativeMonitor(mPtr);
}

static void nativeMonitor(JNIEnv* /* env */, jclass /* clazz */, jlong ptr) {
    NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);

    im->getInputManager()->getReader()->monitor();
    im->getInputManager()->getDispatcher()->monitor();
}

void InputDispatcher::monitor() {
    // Acquire and release the lock to ensure that the dispatcher has not deadlocked.
    mLock.lock();
    // 向主Lopper中发送Wake的消息
    mLooper->wake();
    // 等待主Lopper的响应
    mDispatcherIsAliveCondition.wait(mLock);
    mLock.unlock();
}

void InputDispatcher::dispatchOnce() {
    nsecs_t nextWakeupTime = LONG_LONG_MAX;
    { // acquire lock
        AutoMutex _l(mLock);
        // 在epoll唤醒后 , 会通过broadcast广播让monitor继续执行
        mDispatcherIsAliveCondition.broadcast()
        ....
    }
}