wakelock使用过度的问题。

今天，测试提交了一个bug，说有个任务执行一半没了。（因为任务是由一个不可关闭的dialog控制，换句话说，dialog意外关闭了），差看了下log，细心的发现了一条ActivityManager发出来的log

Killing 10190:com.xxx.xxx.xxx/u0a59 (adj 7):excessive wake held 900036 during 900036

很费解，这是系统杀的，系统为啥杀呢？从字面意思看好像是过度使用了wake（因为dialog有个倒计时，所以，使用了wakelock锁）
那就从系统源码上看吧，ActivityManager发出的信息是在ActivityManagerService里执行的，直接打开该文件，搜索，直接到下面的函数（去掉部分和本次无关的代码）

//这个是检查是否过度使用wakelock以及cpu（cpu部分，有兴趣的自己看源码），如果过渡使用，则干掉
//这个检查函数是每隔15分钟检查一次的，从开机的时候开始。
final void checkExcessivePowerUsageLocked(boolean doKills) {
        updateCpuStatsNow();

        BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();  //wakelock一些信息是在BatteryStats里保存的
        boolean doWakeKills = doKills;  //刚开始是true，也就是默认要干掉
        boolean doCpuKills = doKills;
        if (mLastPowerCheckRealtime == 0) {
            doWakeKills = false;  //这个是上次检查的时间，如果是0，则表示这是第一次检查，则不会干掉任何进程（开机完成即启用第一次检查）
        }
       //.....
        if (stats.isScreenOn()) {
            doWakeKills = false;//如果屏幕开启的时候也不会干掉，所以这个是为了防止后台的。
        }
        final long curRealtime = SystemClock.elapsedRealtime();
        final long realtimeSince = curRealtime - mLastPowerCheckRealtime;  //从上次检查到现在的时间
        final long curUptime = SystemClock.uptimeMillis();
        final long uptimeSince = curUptime - mLastPowerCheckUptime;
        mLastPowerCheckRealtime = curRealtime;
        mLastPowerCheckUptime = curUptime;
        if (realtimeSince < WAKE_LOCK_MIN_CHECK_DURATION) {
            doWakeKills = false;  //如果检查时间小于5分钟，则不杀进程，WAKE_LOCK_MIN_CHECK_DURATION是5分钟，可以自己看下定义
        }
        if (uptimeSince < CPU_MIN_CHECK_DURATION) {
            doCpuKills = false;
        }
        int i = mLruProcesses.size();
        while (i > 0) {  //遍历所有进程
            i--;
            ProcessRecord app = mLruProcesses.get(i);
            if (app.setProcState >= ActivityManager.PROCESS_STATE_HOME) {
                //对于setProcState>=PROCESS_STATE_HOME生效，这个定义，每个sdk可能不一样，大概是状态是在后台或者更低级别（数值越小，优先级越高，换句话说，如果当前正在显示或者是在前台的，即使关闭屏幕也不会被杀掉，所以，测试条件一定是返回桌面，并且关闭屏幕）
                long wtime;
                synchronized (stats) {
                    wtime = stats.getProcessWakeTime(app.info.uid,
                            app.pid, curRealtime);  //根据进程的uid和pid查找上次使用wakelock的时间，便于计算使用wakelock时间
                }
                long wtimeUsed = wtime - app.lastWakeTime;
                long cputimeUsed = app.curCpuTime - app.lastCpuTime;

                //其实这句话已经解释得很清楚了，一个进程如果拥有wakelock超过他总长时间的一半，就直接杀掉。
                //加上前面的判断，如果一个进程在后台，并且屏幕关闭的条件下，如果存在时间超过5分钟，并且，使用wakelock的时间超过总时间的一半，则杀掉）
                // If a process has held a wake lock for more
                // than 50% of the time during this period,
                // that sounds bad.  Kill!
                if (doWakeKills && realtimeSince > 0
                        && ((wtimeUsed*100)/realtimeSince) >= 50) {
                    synchronized (stats) {
                        stats.reportExcessiveWakeLocked(app.info.uid, app.processName,
                                realtimeSince, wtimeUsed);
                    }
                    //这个就是杀进程，也是通过这句log查找到这儿的。
                    app.kill("excessive wake held " + wtimeUsed + " during " + realtimeSince, true);
                    app.baseProcessTracker.reportExcessiveWake(app.pkgList);
                } 
                //......其他的判断，其中cpu是使用超过四分一，有兴趣自己看。
            }
        }
    }

ok，杀进程的函数已经找到了，那么，什么时候调用的呢？

final class MainHandler extends Handler {
        public MainHandler(Looper looper) {
            super(looper, null, true);
        }

        @Override
        public void handleMessage(Message msg) {
            switch (msg.what) {
           //other case
            case CHECK_EXCESSIVE_WAKE_LOCKS_MSG: {
                synchronized (ActivityManagerService.this) {
                    //调用刚才分析的函数，并且，默认的kill操作是true的
                    checkExcessivePowerUsageLocked(true);
                    removeMessages(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);
                    Message nmsg = obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);  //继续发送同一个信息，也就是定时检查，检查间隔是POWER_CHECK_DELAY，15分钟
                    sendMessageDelayed(nmsg, POWER_CHECK_DELAY);
                }
            } break;
            //other cases
        }
    };

ok，很简单，就是一个handler处理机制，并且15分钟定时检查，那么第一条信息是谁发送的呢？继续查.

final void finishBooting() {
        //other code

        synchronized (this) {
           //other code

            //这里的mFactoryTest 是不等于FactoryTest.FACTORY_TEST_LOW_LEVEL的，待会儿说
            if (mFactoryTest != FactoryTest.FACTORY_TEST_LOW_LEVEL) {
                // Start looking for apps that are abusing wake locks.
                //这里发送第一条信息
                Message nmsg = mHandler.obtainMessage(CHECK_EXCESSIVE_WAKE_LOCKS_MSG);
                mHandler.sendMessageDelayed(nmsg, POWER_CHECK_DELAY);
               //  other code
        }
    }

这里的函数，从名字看就知道是启动完成后，剩下的就不继续分析了，有兴趣的可以自己再去看下，不过，估计要从开机启动开始分析了。
接下来分析下mFactoryTest这个变量，全局搜索下，就在AMS的构造函数有赋值

 public ActivityManagerService(Context systemContext) {
        mContext = systemContext;
        mFactoryTest = FactoryTest.getMode();
        mSystemThread = ActivityThread.currentActivityThread();

        Slog.i(TAG, "Memory class: " + ActivityManager.staticGetMemoryClass());
        //other code
}

FactoryTest代码太简单了，直接附上代码得了

public final class FactoryTest {
    public static final int FACTORY_TEST_OFF = 0;
    public static final int FACTORY_TEST_LOW_LEVEL = 1;
    public static final int FACTORY_TEST_HIGH_LEVEL = 2;

    /**
     * Gets the current factory test mode.
     *
     * @return One of: {@link #FACTORY_TEST_OFF}, {@link #FACTORY_TEST_LOW_LEVEL},
     * or {@link #FACTORY_TEST_HIGH_LEVEL}.
     */
    public static int getMode() {
        //默认是FACTORY_TEST_OFF（0），而不是FACTORY_TEST_LOW_LEVEL（1），正常的机子都是工厂测试都是关闭的，换句话说，如果是工厂测试的机子，是不会过渡使用的。
        //如果硬是要看的话，可以到以下几个目录查看是否具有该值
        /default.prop
        /system/build.prop
        /system/default.prop
        /data/local.prop
        /data/property目录下所有presist属性
        return SystemProperties.getInt("ro.factorytest", FACTORY_TEST_OFF);
    }

    /**
     * When true, long-press on power should immediately cause the device to
     * shut down, without prompting the user.
     */
    public static boolean isLongPressOnPowerOffEnabled() {
        return SystemProperties.getInt("factory.long_press_power_off", 0) != 0;
    }
}

好了，分析以上的原因就是说下，wakelock虽然好用，但是也不能过度使用，使用的时候先确认下是否真的需要，以及cpu（这个就要避免一直在后台频繁操作了），最后，15分钟检查一次的，如果看了源码会发现，如果调试态是可以缩短的，目前不知道在不动用底层的前提下，如何开启ams调试态（开了调试态，多了很多log，除了这个，也会很有帮助的），如果有知道的，麻烦告知下