代码我写的怎么
代码我写的怎么

Android耗电原理及飞书耗电治理

这篇文章中简绍Android的耗电原理，以及飞书的耗电治理规划。

Android耗电统计原理

我们先了解一下Android系统是如何进行耗电的统计的，最精确的方式当然是使用电流仪来进行统计，但是正常状态下手机硬件不支持，所以系统统计耗电时，使用的基本是模块功率✖️模块耗时这个公式来进行的，但不同的模块还是会有一些差别。这种统计方式没法做到非常的精确，但是也基本能反应出各应用电量的消耗大小。

模块功率

我们先来看看模块功率，每个模块的耗电功率都是不一样的，以计算方式来分，又分为下面三类

  1. 第一类是Camera、FlashLight、MediaPlayer等一般传感器或设备的模块的模块。其工作功率基本和额定功率保持一致，所以模块电量的计算只需要统计模块的使用时长再乘以额定功率即可。

  2. 第二类是Wifi、Mobile、BlueTooth这类数据模块。其工作功率可以分为不同的档位，比如，当手机的 Wifi 信号比较弱的时候，Wifi 模块就必须工作在比较高的功率档位以维持数据链路，所以这类模块的电量计算有点类似于我们日常的电费计算，需要 “阶梯计费”。

  3. 第三类是屏幕，CPU模块。CPU 模块除了每一个CPU Core 需要像数据模块那样阶梯计算电量之外，CPU 的每一个集群（Cluster，一般一个集群包含一个或多个规格相同的 Core）也有额外的耗电，此外整个 CPU 处理器芯片也有功耗。简单计算的话，CPU 电量 = SUM (各核心功耗) + 各集群（Cluster）功耗 + 芯片功耗 。屏幕模块的电量计算就更麻烦了，很难把屏幕功耗合理地分配给各个 App， 因此 Android 系统只是简单地计算 App 屏幕锁（WakeLock）的持有时长，按固定系数增加 App CPU 的统计时长，粗略地把屏幕功耗算进 CPU 里面。

每个模块的功耗大小位于framework的power_profile.xml文件中，由厂商自己提供，里面规定了每个模块的功耗，下面是一台一加9的测试机的power_profile文件

通过apktook反解出来的power_profile如下

文件中每个模块的对应说明，可以在谷歌提供的文档中看到详细的说明。

source.android.com/devices/tec…

模块耗时

了解了模块的功率，我们再来看看模块耗时，耗电模块在工作或者状态变更时，都会通知batterystats这个service，而BatteryStatsService会调用BatteryStats对象进行耗时的统计，BatteryStats的构造函数中会初始化各个模块的Timer，用来进行耗时的统计，并将统计的数据存储在batterystats.bin文件中。

BatteryStatsImpl.java

我们来详细看看下面几个模块的是如何进统计的，

  • wifi模块
    public void noteWifiOnLocked() {
        if (!mWifiOn) {
            final long elapsedRealtime = mClocks.elapsedRealtime();
            final long uptime = mClocks.uptimeMillis();
            mHistoryCur.states2 |= HistoryItem.STATE2_WIFI_ON_FLAG;
            addHistoryRecordLocked(elapsedRealtime, uptime);
            mWifiOn = true;
            mWifiOnTimer.startRunningLocked(elapsedRealtime);
            scheduleSyncExternalStatsLocked("wifi-off", ExternalStatsSync.UPDATE_WIFI);
        }
    }

    public void noteWifiOffLocked() {
        final long elapsedRealtime = mClocks.elapsedRealtime();
        final long uptime = mClocks.uptimeMillis();
        if (mWifiOn) {
            mHistoryCur.states2 &= ~HistoryItem.STATE2_WIFI_ON_FLAG;
            addHistoryRecordLocked(elapsedRealtime, uptime);
            mWifiOn = false;
            mWifiOnTimer.stopRunningLocked(elapsedRealtime);
            scheduleSyncExternalStatsLocked("wifi-on", ExternalStatsSync.UPDATE_WIFI);
        }
    }
  • Audio模块
    public void noteAudioOnLocked(int uid) {
        uid = mapUid(uid);
        final long elapsedRealtime = mClocks.elapsedRealtime();
        final long uptime = mClocks.uptimeMillis();
        if (mAudioOnNesting == 0) {
            mHistoryCur.states |= HistoryItem.STATE_AUDIO_ON_FLAG;
            if (DEBUG_HISTORY) Slog.v(TAG, "Audio on to: "
                    + Integer.toHexString(mHistoryCur.states));
            addHistoryRecordLocked(elapsedRealtime, uptime);
            mAudioOnTimer.startRunningLocked(elapsedRealtime);
        }
        mAudioOnNesting++;
        getUidStatsLocked(uid).noteAudioTurnedOnLocked(elapsedRealtime);
    }

    public void noteAudioOffLocked(int uid) {
        if (mAudioOnNesting == 0) {
            return;
        }
        uid = mapUid(uid);
        final long elapsedRealtime = mClocks.elapsedRealtime();
        final long uptime = mClocks.uptimeMillis();
        if (--mAudioOnNesting == 0) {
            mHistoryCur.states &= ~HistoryItem.STATE_AUDIO_ON_FLAG;
            if (DEBUG_HISTORY) Slog.v(TAG, "Audio off to: "
                    + Integer.toHexString(mHistoryCur.states));
            addHistoryRecordLocked(elapsedRealtime, uptime);
            mAudioOnTimer.stopRunningLocked(elapsedRealtime);
        }
        getUidStatsLocked(uid).noteAudioTurnedOffLocked(elapsedRealtime);
    }
  • Activity状态改变
public void noteActivityResumedLocked(int uid) {
    uid = mapUid(uid);
    getUidStatsLocked(uid).noteActivityResumedLocked(mClocks.elapsedRealtime());
}

public void noteActivityPausedLocked(int uid) {
    uid = mapUid(uid);
    getUidStatsLocked(uid).noteActivityPausedLocked(mClocks.elapsedRealtime());
}

public static class Uid extends BatteryStats.Uid {

    @Override
    public void noteActivityPausedLocked(long elapsedRealtimeMs) {
        if (mForegroundActivityTimer != null) {
            mForegroundActivityTimer.stopRunningLocked(elapsedRealtimeMs);
        }
    }

    @Override
    public void noteActivityPausedLocked(long elapsedRealtimeMs) {
        if (mForegroundActivityTimer != null) {
            mForegroundActivityTimer.stopRunningLocked(elapsedRealtimeMs);
        }
    }

}

通过上面三个例子可以看到，BatteryStats在统计模块耗时，主要通过Timer来进行时长的统计，如WifiOnTimer、AudioOnTimer、ForegroundActivityTimer，并且根据是否有UID来决定是否要统计到UID对应的数据中，系统在统计应用的耗电时，就是根据UID下各个模块的统计数据，来进行应用的耗电计算的。

耗电计算

当我们知道了每个模块的耗时，每个模块的功耗，那么就能计算各个模块的耗电量了，耗电量的计算在BatteryStatsHelper这个类中，下面详细看一下Setting中，应用耗电详情这个功能统计耗电的实现，Setting中的耗电统计这个应用主要是调用了BatteryStatsHelper中的refreshStats() 函数

refreshStats主要两个方法是processappUsage计算应用的耗电，记忆processMiscUsage计算杂项耗电，如WIFI，通话等等

  • 计算app的电量

这里以CameraPowerCalculator这个简单的模块看看它是如何统计电量的

CameraPowerCalculator.java

可以看到，里面只是简单的用了totalTime * mCameraPowerOnAvg，mCameraPowerOnAvg则是从power_profile.xml读取出来，其他教负责的如CPU模块的计算，感兴趣的可以自己看看，就不在这里说了。

  • 计算misc杂项的电量

杂项电量用来统计一些没有特定UID的耗电，如蓝牙，屏幕等等，计算方式也是类似的。

Android的耗电优化策略

Doze模式

Doze模式也被称为低电耗模式，是针对整个系统进行一个耗电优化策略，进入Doze模式后会暂停所有的Jobs，Alarm和Network活动并推迟到窗口期执行，以及其他的一些限制来节约电量。

Doze模式的进入和退出

Doze模式分为Deep Doze和Light Doze两种模式，Doze模式是在Android6.0引入的，也就是Deep Doze模式，Light Doze是Android7.0引入的，两者进入的条件不一样，Deep Doze的条件会更严格，下面先介绍Deep Doze

Deep Doze

系统处于息屏状态，并且30分钟不移动的情况下，就会进入到Deep Doze模式，Deep Doze机制中有七种状态，分别如下

//mState值，表示设备处于活动状态
private static final int STATE_ACTIVE = 0;
//mState值，表示设备处于不交互状态,灭屏、静止
private static final int STATE_INACTIVE = 1;
//mState值，表示设备刚结束不交互状态,等待进入IDLE状态
private static final int STATE_IDLE_PENDING = 2;
//mState值，表示设备正在感应动作
private static final int STATE_SENSING = 3;
//mState值，表示设备正在定位
private static final int STATE_LOCATING = 4;
//mState值，表示设备处于空闲状态,也即Doze模式
private static final int STATE_IDLE = 5;
//mState值，表示设备正处于Doze模式，紧接着退出Doze进入维护状态
private static final int STATE_IDLE_MAINTENANCE = 6;

这七种状态的转换关系如下

根据上图，他们的关系总结如下

  1. 当设备亮屏或者处于正常使用状态时其就为ACTIVE状态；

  2. ACTIVE状态下不充电且灭屏设备就会切换到INACTIVE状态；

  3. INACTIVE状态经过30分钟，期间检测没有打断状态的行为Doze就切换到IDLE_PENDING的状态；

  4. 然后再经过30分钟以及一系列的判断，状态切换到SENSING；

  5. 在SENSING状态下会去检测是否有地理位置变化，没有的话就切到LOCATION状态；

  6. LOCATION状态下再经过30s的检测时间之后就进入了Doze的核心状态IDLE；

  7. 在IDLE模式下每隔一段时间就会进入一次IDLE_MAINTANCE，此间用来处理之前被挂起的一些任务，这个时间段为一个小时，两个小时，四个小时，最后稳定为最长为六个小时

  8. IDLE_MAINTANCE状态持续5分钟之后会重新回到IDLE状态；

  9. 在除ACTIVE以外的所有状态中，检测到打断的行为如亮屏、插入充电器，位置的改变等状态就会回到ACTIVE，重新开始下一个轮回。

Light Doze

从上面可以看到想要进入Doze模式的条件是很苛刻，需要在手机息屏并且没有移动的状态下才能进入，所以Android7.0开始引入了Light Doze，处于息屏状态，但仍处于移动状态可进入Light Doze，LightDoze有7个状态，分别如下：

//mLightState状态值，表示设备处于活动状态
private static final int LIGHT_STATE_ACTIVE = 0;
//mLightState状态值，表示设备处于不活动状态
private static final int LIGHT_STATE_INACTIVE = 1;
//mLightState状态值，表示设备进入空闲状态前，需要等待完成必要操作
private static final int LIGHT_STATE_PRE_IDLE = 3;
//mLightState状态值，表示设备处于空闲状态，该状态内将进行优化
private static final int LIGHT_STATE_IDLE = 4;
//mLightState状态值，表示设备处于空闲状态,要进入维护状态，先等待网络连接
private static final int LIGHT_STATE_WAITING_FOR_NETWORK = 5;
//mLightState状态值，表示设备处于维护状态
private static final int LIGHT_STATE_IDLE_MAINTENANCE = 6;

这个6个状态的转换关系如下

根据上图，他们的转换关系总结如下

  1. 当设备亮屏或者处于正常使用状态时其就为ACTIVE状态；

  2. ACTIVE状态下不充电且灭屏设备就会切换到INACTIVE状态；

  3. INACTIVE状态经过3分钟，期间检测没有打断状态的行为就切换到PRE_IDLE的状态；

  4. PRE_IDLE状态经过5分钟，期间无打断就进入到IDLE状态

  5. 进入IDLE状态会根据是否有网络连接选择进入WAITING_FOR_NETWORK还是进入MAINTENANCE窗口期，进入窗口期的时间为：5分钟，10分钟，最后稳定最长为15分钟

  6. 进入WAITING_FOR_NETWORK会持续5分钟后重新进入到IDLE状态

  7. 进入MAINTENANCE会解除耗电策略的限制，并在1分钟后重新进入到IDLE状态

Doze模式的优化策略

了解了Doze模式的进入和退出策略，我们再来看一下在Doze模式中，会做哪些策略来优化耗电

Deep Doze

当系统处于Doze模式下，系统和白名单之外的应用将受到以下限制：

  • 无法访问网络

  • Wake Locks被忽略

  • AlarmManager闹铃会被推迟到下一个maintenance window响应

    • 使用setAndAllowWhileIdle或SetExactAndAllowWhileIdle设置闹铃的闹钟则不会受到Doze模式的影响
    • setAlarmClock设置的闹铃在Doze模式下仍然生效，但系统会在闹铃生效前退出Doze

  • 系统不执行Wi-Fi/GPS扫描；

  • 系统不允许同步适配器运行；

  • 系统不允许JobScheduler运行；

Deep Doze也提供了白名单，位于白名单中的应用可以：

  • 继续使用网络并保留部分wake lock

  • Job和同步仍然会被推迟

  • 常规的AlarmManager闹铃也不会被触发

Light Doze

Light Doze的限制没有Deep Doze这么严格，主要有下面几种

  • 不允许进行网络访问

  • 不允许同步适配器运行

  • 不允许JobScheduler运行

Deep Doze和Light Doze的总结对比如下：

Deep Doze和Light Doze都需要达到一定条件后才能进入，并且进入后会定期提供窗口期来解除限制。

他们的对比如下

操作 Deep Doze Light Doze
触发因素 屏幕关闭，无充电，静止 屏幕关闭，无充电
维持时间 不断增长，最长为6个小时 不断增长，最长为15分钟
限制 无法进行网络访问，唤醒锁忽略，GPS/WIFI/蓝牙等无法扫描，闹钟/SyncAdapter/JobScheduler推迟 无法进行网络访问，SyncAdapter/JobScheduler推迟
退出 设备移动，和用户有交互，屏幕开启 屏幕开启

Doze模式实现原理

前面已经了解了Doze模式了，下面就在通过Android中的Doze机制的源码，深入了解Doze的实现原理。Doze机制相关的源码都在DeviceIdleController这个类中

DeviceIdleController.java

进入INACTIVE状态

从ACTIVIE进入到INACTIVE的入口方法是becomeInactiveIfAppropriateLocked中，当充电状态发生改变，屏幕息屏等条件触发时，都会调用该方法判断是否可进入INACTIVE状态。

//deep doze进入INACTIVE后的延时时间，这里的COMPRESS_TIME默认为false
long inactiveTimeoutDefault = (mSmallBatteryDevice ? 15 : 30) * 60 * 1000L;
INACTIVE_TIMEOUT = mParser.getDurationMillis(KEY_INACTIVE_TIMEOUT,
                !COMPRESS_TIME ? inactiveTimeoutDefault : (inactiveTimeoutDefault / 10));

LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT = mParser.getDurationMillis(
        KEY_LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT,
        !COMPRESS_TIME ? 3 * 60 * 1000L : 15 * 1000L);

void becomeInactiveIfAppropriateLocked() {
    final boolean isScreenBlockingInactive =
            mScreenOn && (!mConstants.WAIT_FOR_UNLOCK || !mScreenLocked);
    //判断是否是灭屏且非充电状态
    if (!mForceIdle && (mCharging || isScreenBlockingInactive)) {
        return;
    }

    if (mDeepEnabled) {
        if (mQuickDozeActivated) {
            //1\. QuickDoze是Android 10新引入的低电量的情况下，快速进入Doze的机制，会缩短进入Doze的耗时
            if (mState == STATE_QUICK_DOZE_DELAY || mState == STATE_IDLE
                    || mState == STATE_IDLE_MAINTENANCE) {
                return;
            }
            mState = STATE_QUICK_DOZE_DELAY;
            resetIdleManagementLocked();
            scheduleAlarmLocked(mConstants.QUICK_DOZE_DELAY_TIMEOUT, false);
            EventLogTags.writeDeviceIdle(mState, "no activity");
        } else if (mState == STATE_ACTIVE) {
            mState = STATE_INACTIVE;
            resetIdleManagementLocked();
            long delay = mInactiveTimeout;
            if (shouldUseIdleTimeoutFactorLocked()) {
                delay = (long) (mPreIdleFactor * delay);
            }
            //2\. 执行时间为mInactiveTimeout延时的任务，这里是30分钟
            scheduleAlarmLocked(delay, false);
            EventLogTags.writeDeviceIdle(mState, "no activity");
        }
    }
    if (mLightState == LIGHT_STATE_ACTIVE && mLightEnabled) {
        mLightState = LIGHT_STATE_INACTIVE;
        resetLightIdleManagementLocked();
        //3\. 执行时间为LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT延时的任务，这里是3分钟
        scheduleLightAlarmLocked(mConstants.LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT);
        EventLogTags.writeDeviceIdleLight(mLightState, "no activity");
    }
}

从源码中可以看到Deep Doze，Light Doze的处理都在这里，并且这里还有一个Quick Doze，它是Android 10引入，能在低电量情况下快速进入Doze的机制。

我们接着看INACTIVE向下一个状态的改变

  • Deep Doze通过scheduleAlarmLocked(delay, false)向下一个状态转变，在这个时间过程中，有开屏，充电等操作，都会导致状态转换失败

  • Light Doze通过scheduleLightAlarmLocked(mConstants.LIGHT_IDLE_AFTER_INACTIVE_TIMEOUT)向下一个状态改变，同样在开屏和充电状态下，都会导致进入下一个状态失败

从INACTIVE状态开始，Light Doze和Deep Doze转换的入口就不一样了，所以下面会分开讲解

Deep Doze

1. 从INACTIVE进入STATE_IDLE_PENDING

becomeInactiveIfAppropriateLocked函数中将mState设置为STATE_INACTIVE，然后调用scheduleAlarmLocked设置了一个30分钟的定时任务，它的逻辑实现如下。

void scheduleAlarmLocked(long delay, boolean idleUntil) {
    if (mMotionSensor == null) {
    //如果没有运动传感器，则返回，因为无法判断设备是否保持静止
    if (mMotionSensor == nullr) {
        return;
    }
    //设置DeepDoze的定时Alarm
    mNextAlarmTime = SystemClock.elapsedRealtime() + delay;
    if (idleUntil) {
        mAlarmManager.setIdleUntil(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                mNextAlarmTime, "DeviceIdleController.deep", 
                mDeepAlarmListener, mHandler);
    } else {
        mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
                mNextAlarmTime, "DeviceIdleController.deep", 
                mDeepAlarmListener, mHandler);
    }
}

private final AlarmManager.OnAlarmListener mDeepAlarmListener
        = new AlarmManager.OnAlarmListener() {
    @Override
    public void onAlarm() {
        synchronized (DeviceIdleController.this) {
            ///每次Doze状态转换都会在该方法中进行
            stepIdleStateLocked("s:alarm");
        }
    }
};

Deep Doze的scheduleAlarmLocked定时任务触发后，会回调onAlarm，执行stepIdleStateLocked函数。

void stepIdleStateLocked(String reason) {
    final long now = SystemClock.elapsedRealtime();
    //说明1小时内有Alarm定时时间到，暂不进入IDLE状态，30min后再进入
    if ((now+mConstants.MIN_TIME_TO_ALARM) > 
               mAlarmManager.getNextWakeFromIdleTime()) {
        if (mState != STATE_ACTIVE) {
            //将当前设备变为活动状态，LightDoze和DeepDoze都为Active状态
            becomeActiveLocked("alarm", Process.myUid());
            becomeInactiveIfAppropriateLocked();
        }
        return;
    }
    switch (mState) {
        case STATE_INACTIVE:
            //启动Sensor
            startMonitoringMotionLocked();
            //设置STATE_IDLE_PENDING状态时长的定时Alarm，30mins
            scheduleAlarmLocked(mConstants.IDLE_AFTER_INACTIVE_TIMEOUT,
                   false);
            mNextIdlePendingDelay = mConstants.IDLE_PENDING_TIMEOUT;//5mins
            mNextIdleDelay = mConstants.IDLE_TIMEOUT;//60mins
            //此时状态变为PENDING状态
            mState = STATE_IDLE_PENDING;
            break;
        case STATE_IDLE_PENDING:
            //此时状态变为SENSING状态
            mState = STATE_SENSING;
            //设置STATE_SENSING状态超时时长的定时Alarm，DEBUG?1:4mins
            scheduleSensingTimeoutAlarmLocked(mConstants.SENSING_TIMEOUT);
            //取消通用位置更新和GPS位置更新
            cancelLocatingLocked();
            mNotMoving = false;
            mLocated = false;
            mLastGenericLocation = null;
            mLastGpsLocation = null;
            //开始检测是否有移动
            mAnyMotionDetector.checkForAnyMotion();
            break;
        case STATE_SENSING:
            //取消用于STATE_SENSING状态超时时长的Alarm
            cancelSensingTimeoutAlarmLocked();
            //此时状态变为LOCATING
            mState = STATE_LOCATING;
            //设置STATE_LOCATING状态时长的Alarm
            scheduleAlarmLocked(mConstants.LOCATING_TIMEOUT, 
                     false);//DEBUG?15:30
            //请求通用位置
            if (mLocationManager != null
                    && mLocationManager.getProvider(LocationManager.
                     NETWORK_PROVIDER) != null) {
                mLocationManager.requestLocationUpdates(mLocationRequest,
                        mGenericLocationListener, mHandler.getLooper());
                mLocating = true;
            } else {
                mHasNetworkLocation = false;
            }
            //请求GPS位置
            if (mLocationManager != null
                    && mLocationManager.getProvider(LocationManager.
                    GPS_PROVIDER) != null) {
                mHasGps = true;
                mLocationManager.requestLocationUpdates(LocationManager.
                        GPS_PROVIDER, 1000, 5,
                        mGpsLocationListener, mHandler.getLooper());
                mLocating = true;
            } else {
                mHasGps = false;
            }
            //如果true,则break，因为在Location的Listener中会进入下一个状态，
            //否则进入下一步状态
            if (mLocating) {
                break;
            }
        case STATE_LOCATING:
            //取消DeepDoze的Alarm
            cancelAlarmLocked();
            //取消位置更新
            cancelLocatingLocked();
            //Sensor停止检测
            mAnyMotionDetector.stop();
        case STATE_IDLE_MAINTENANCE:
            //设置STATE_IDLE状态时长的定时Alarm，到时后将退出IDLE状态
            scheduleAlarmLocked(mNextIdleDelay, true);
            //设置下次IDLE时间
            mNextIdleDelay = (long)(mNextIdleDelay * mConstants.IDLE_FACTOR);
            mNextIdleDelay = Math.min(mNextIdleDelay, mConstants.MAX_IDLE_TIMEOUT);
            if (mNextIdleDelay < mConstants.IDLE_TIMEOUT) {
                mNextIdleDelay = mConstants.IDLE_TIMEOUT;
            }
            mState = STATE_IDLE;
            //进入DeepDoze的IDLE后，覆盖LightDoze
            if (mLightState != LIGHT_STATE_OVERRIDE) {
                mLightState = LIGHT_STATE_OVERRIDE;
                //取消LightDoze的定时Alarm
                cancelLightAlarmLocked();
            }
            //申请wakelock保持CPU唤醒
            mGoingIdleWakeLock.acquire();
            //handler中处理idle状态后各个模块的限制工作
            mHandler.sendEmptyMessage(MSG_REPORT_IDLE_ON);
            break;
        case STATE_IDLE:
            mActiveIdleOpCount = 1;//表示现在有正在活动的操作
            //申请wakelock锁保持cpu唤醒
            mActiveIdleWakeLock.acquire();
            //设置STATE_IDLE_MAINTENANCE状态时长的定时Alarm，
            //到时后将退出维护状态
            scheduleAlarmLocked(mNextIdlePendingDelay, false);
            mMaintenanceStartTime = SystemClock.elapsedRealtime();
            mNextIdlePendingDelay = 
                 Math.min(mConstants.MAX_IDLE_PENDING_TIMEOUT,
                    (long)(mNextIdlePendingDelay * 
                    mConstants.IDLE_PENDING_FACTOR));
            if (mNextIdlePendingDelay < mConstants.IDLE_PENDING_TIMEOUT) {
                mNextIdlePendingDelay = mConstants.IDLE_PENDING_TIMEOUT;
            }
            mState = STATE_IDLE_MAINTENANCE;
            //Handler中处理退出idle状态进入维护状态后取消限制的工作
            mHandler.sendEmptyMessage(MSG_REPORT_IDLE_OFF);
            break;
    }
}

可以看到，Deep Doze的状态转换都是通过scheduleAlarmLocked和stepIdleStateLocked这两个函数进行的。 在case为STATE_INACTIVE的逻辑中，将mState设置成了STATE_IDLE_PENDING，启动Sensor监听，并设置了一个30分钟的延时任务。

2. 从STATE_DLE_PENDING进入STATE_SENSING

当30分钟无中断，state就从PENDING进入到了SENSING状态中。

case STATE_IDLE_PENDING:
    //此时状态变为SENSING状态
    mState = STATE_SENSING;
    //设置STATE_SENSING状态超时时长的定时Alarm，4分钟
    scheduleSensingTimeoutAlarmLocked(mConstants.SENSING_TIMEOUT);
    //取消通用位置更新和GPS位置更新
    cancelLocatingLocked();
    mNotMoving = false;
    mLocated = false;
    mLastGenericLocation = null;
    mLastGpsLocation = null;
    //开始检测是否有运动
    mAnyMotionDetector.checkForAnyMotion();
    break;

在这个状态中，会开始运动检测，并持续4分钟。

3. 从STATE_SENSING进入到STATE_LOCATING
4. 从STATE_LOCATING进入到STATE_IDLE
5. 从STATE_IDLE_MAINTENANCE进入到STATE_IDLE

SENSING的下一个状态是STATE_LOCATING，STATE_LOCATING和STATE_IDLE_MAINTENANCE的下一个状态都是STATE_IDLE，这里一起讲

case STATE_SENSING:
    //取消用于STATE_SENSING状态超时时长的Alarm
    cancelSensingTimeoutAlarmLocked();
    //此时状态变为LOCATING
    mState = STATE_LOCATING;
    //设置STATE_LOCATING状态时长的Alarm,
    scheduleAlarmLocked(mConstants.LOCATING_TIMEOUT, 
             false);
    //请求通用位置
    if (mLocationManager != null
            && mLocationManager.getProvider(LocationManager.
             NETWORK_PROVIDER) != null) {
        mLocationManager.requestLocationUpdates(mLocationRequest,
                mGenericLocationListener, mHandler.getLooper());
        mLocating = true;
    } else {
        mHasNetworkLocation = false;
    }
    //请求GPS位置
    if (mLocationManager != null
            && mLocationManager.getProvider(LocationManager.
            GPS_PROVIDER) != null) {
        mHasGps = true;
        mLocationManager.requestLocationUpdates(LocationManager.
                GPS_PROVIDER, 1000, 5,
                mGpsLocationListener, mHandler.getLooper());
        mLocating = true;
    } else {
        mHasGps = false;
    }
    //如果true,则break，因为在Location的Listener中会进入下一个状态，
    //否则进入下一步状态
    if (mLocating) {
        break;
    }
case STATE_LOCATING:
        //取消DeepDoze的Alarm
        cancelAlarmLocked();
        //取消位置更新
        cancelLocatingLocked();
        //Sensor停止检测
        mAnyMotionDetector.stop();
case STATE_IDLE_MAINTENANCE:
    //设置STATE_IDLE状态时长的定时Alarm，到时后将退出IDLE状态
    scheduleAlarmLocked(mNextIdleDelay, true);
    //设置下次IDLE时间
    mNextIdleDelay = (long)(mNextIdleDelay * mConstants.IDLE_FACTOR);
    mNextIdleDelay = Math.min(mNextIdleDelay, mConstants.MAX_IDLE_TIMEOUT);
    if (mNextIdleDelay < mConstants.IDLE_TIMEOUT) {
        mNextIdleDelay = mConstants.IDLE_TIMEOUT;
    }
    mState = STATE_IDLE;
    //进入DeepDoze的IDLE后，覆盖LightDoze
    if (mLightState != LIGHT_STATE_OVERRIDE) {
        mLightState = LIGHT_STATE_OVERRIDE;
        //取消LightDoze的定时Alarm
        cancelLightAlarmLocked();
    }
    //申请wakelock保持CPU唤醒
    mGoingIdleWakeLock.acquire();
    //handler中处理idle状态后各个模块的限制工作
    mHandler.sendEmptyMessage(MSG_REPORT_IDLE_ON);
    break;

在这个过程中检测是否有gps以及是否有位置移动，如果有gps，则通过break跳出循环，并进行30S的位置移动检测；没有gps，则进入到case为STATE_IDLE_MAINTENANCE的处理中，并将state设置为STATE_IDLE。

进入到STATE_IDLE后，会申请wakelock，同时调用MSG_REPORT_IDLE_ON的handler任务来进行耗电策略的限制，这里和light doze的idle状态处理都是同一个入口，所以MSG_REPORT_IDLE_ON在下面light doze中在详细将。

同时，我们可以看到，进入STATE_IDLE后，会设置一个时间为：

IDLE_TIMEOUT = mParser.getDurationMillis(KEY_IDLE_TIMEOUT,
        !COMPRESS_TIME ? 60 * 60 * 1000L : 6 * 60 * 1000L);

mNextIdleDelay = (long)(mNextIdleDelay * mConstants.IDLE_FACTOR);
mNextIdleDelay = Math.min(mNextIdleDelay, mConstants.MAX_IDLE_TIMEOUT);
if (mNextIdleDelay < mConstants.IDLE_TIMEOUT) {
    mNextIdleDelay = mConstants.IDLE_TIMEOUT;
}

的延时任务，IDLE_FACTOR为2，mNextIdleDelay初始值为60分钟，MAX_IDLE_TIMEOUT为6个小时，所以这个时间为1个小时，2个小时，4个小时，最后稳定为6个小时

6. 从STATE_IDLE进入到STATE_IDLE_MAINTENANCE
case STATE_IDLE:
        mActiveIdleOpCount = 1;//表示现在有正在活动的操作
        //申请wakelock锁保持cpu唤醒
        mActiveIdleWakeLock.acquire();
        //设置STATE_IDLE_MAINTENANCE状态时长的定时Alarm，
        //到时后将退出维护状态
        scheduleAlarmLocked(mNextIdlePendingDelay, false);
        mMaintenanceStartTime = SystemClock.elapsedRealtime();
        mNextIdlePendingDelay = 
             Math.min(mConstants.MAX_IDLE_PENDING_TIMEOUT,
                (long)(mNextIdlePendingDelay * 
                mConstants.IDLE_PENDING_FACTOR));
        if (mNextIdlePendingDelay < mConstants.IDLE_PENDING_TIMEOUT) {
            mNextIdlePendingDelay = mConstants.IDLE_PENDING_TIMEOUT;
        }
        mState = STATE_IDLE_MAINTENANCE;
        //Handler中处理退出idle状态进入维护状态后取消限制的工作
        mHandler.sendEmptyMessage(MSG_REPORT_IDLE_OFF);
        break;

进入MAINTENANCE状态后，会在MSG_REPORT_IDLE_OFF的handler中取消各种限制，并位置mNextIdlePendingDelay时间段

mNextIdlePendingDelay = 
         Math.min(mConstants.MAX_IDLE_PENDING_TIMEOUT,
            (long)(mNextIdlePendingDelay * 
            mConstants.IDLE_PENDING_FACTOR));
if (mNextIdlePendingDelay < mConstants.IDLE_PENDING_TIMEOUT) {
    mNextIdlePendingDelay = mConstants.IDLE_PENDING_TIMEOUT;
}

IDLE_PENDING_TIMEOUT为5分钟

Light Doze

1. 从INACTIVE进入LIGHT_STATE_PRE_IDLE

scheduleLightAlarmLocked到达时间后，会触发下面的回调

void scheduleLightAlarmLocked(long delay) {
    mNextLightAlarmTime = SystemClock.elapsedRealtime() + delay;
    //到达时间后，回调mLightAlarmListener.onAlarm()
    mAlarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP,
            mNextLightAlarmTime, "DeviceIdleController.light", 
            mLightAlarmListener, mHandler);
}

private final AlarmManager.OnAlarmListener mLightAlarmListener
        = new AlarmManager.OnAlarmListener() {
    @Override
    public void onAlarm() {
        synchronized (DeviceIdleController.this) {
            //每次LightDoze的状态改变，都会调用该方法进行处理
            stepLightIdleStateLocked("s:alarm");
        }
    }
};

Light Doze的状态改变也都是在stepLightIdleStateLocked函数中处理

void stepLightIdleStateLocked(String reason) {
    //如果mLigthSate为LIGHT_STATE_OVERRIDE,说明DeepDoze处于Idle状态，由
    // DeepDoze将LightDoze覆盖了，因此不需要进行LightDoze了
    if (mLightState == LIGHT_STATE_OVERRIDE) {
        return;
    }
    switch (mLightState) {
        case LIGHT_STATE_INACTIVE:
            //当前最小预算时间
            mCurIdleBudget = 
              mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET;//1min
            //表示LightDoze 进入空闲(Idle)状态的时间
            mNextLightIdleDelay = mConstants.LIGHT_IDLE_TIMEOUT;//5mins
            //LightDoze进入维护状态(maintenance)的开始时间
            mMaintenanceStartTime = 0;
            if (!isOpsInactiveLocked()) {
                //将状态置为LIGHT_STATE_PRE_IDLE状态
                mLightState = LIGHT_STATE_PRE_IDLE;
                //设置一个3分钟的定时器
                scheduleLightAlarmLocked(mConstants.LIGHT_PRE_
                  IDLE_TIMEOUT);
                break;
            }
        case LIGHT_STATE_PRE_IDLE:
        case LIGHT_STATE_IDLE_MAINTENANCE:
            if (mMaintenanceStartTime != 0) {
            //维护状态的时长
                long duration = SystemClock.elapsedRealtime() - 
                 mMaintenanceStartTime;
                if (duration < 
                 mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET) {
                    mCurIdleBudget += (mConstants.LIGHT_IDLE_MAINTENANCE
                       _MIN_BUDGET-duration);
                } else {
                    mCurIdleBudget -= (duration-mConstants.LIGHT_IDLE_
                      MAINTENANCE_MIN_BUDGET);
                }
            }
            mMaintenanceStartTime = 0;//重置维护开始时间
            //设置一个定时器，到达时间后用来处理LightDoze处于IDLE状态的操作
            scheduleLightAlarmLocked(mNextLightIdleDelay);
           //计算下次进入Idle状态的
            mNextLightIdleDelay = 
            Math.min(mConstants.LIGHT_MAX_IDLE_TIMEOUT,
                    (long)(mNextLightIdleDelay * 
                mConstants.LIGHT_IDLE_FACTOR));
            if (mNextLightIdleDelay < mConstants.LIGHT_IDLE_TIMEOUT) {
                mNextLightIdleDelay = mConstants.LIGHT_IDLE_TIMEOUT;
            }
            //将LightDoze模式置为IDLE状态,开始进行一些限制
            mLightState = LIGHT_STATE_IDLE;
            addEvent(EVENT_LIGHT_IDLE);
            //申请一个wakelock锁，保持CPU唤醒
            mGoingIdleWakeLock.acquire();
            //处理LightDoze进入Idle状态后的操作
            mHandler.sendEmptyMessage(MSG_REPORT_IDLE_ON_LIGHT);
            break;
        case LIGHT_STATE_IDLE:
        case LIGHT_STATE_WAITING_FOR_NETWORK:
            if (mNetworkConnected || mLightState == 
            LIGHT_STATE_WAITING_FOR_NETWORK) {
                //如果网络有链接或者当前LightDoze模式为等待网络状态，则进行维护，
                // 并将LightDoze模式退出IDLE状态,进入维护状态
                mActiveIdleOpCount = 1;
                mActiveIdleWakeLock.acquire();
                mMaintenanceStartTime = SystemClock.elapsedRealtime();
            // 保证10<=mCurIdleBudget<=30mins ，mCurIdleBudget是维护状态的时间
                if (mCurIdleBudget < 
                mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET) {
                    mCurIdleBudget = 
                     mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET;
                } else if (mCurIdleBudget > 
                mConstants.LIGHT_IDLE_MAINTENANCE_MAX_BUDGET) {
                    mCurIdleBudget = 
                    mConstants.LIGHT_IDLE_MAINTENANCE_MAX_BUDGET;
                }
                //设置一个定时器，到达时间后用来处理LightDoze处于维护状态的操作
                scheduleLightAlarmLocked(mCurIdleBudget);
                mLightState = LIGHT_STATE_IDLE_MAINTENANCE;//进入维护状态
                addEvent(EVENT_LIGHT_MAINTENANCE);
                //处理LightDoze进入Maintenance状态后的操作
                mHandler.sendEmptyMessage(MSG_REPORT_IDLE_OFF);
            } else {
                //将LightDoze模式置为LIGHT_STATE_WAITING_FOR_NETWORK,
            //在进入维护状态前需要获取网络
                //设置一个定时器，到达时间后用来处理LightDoze处于
            //WAITING_FOR_NETWORK状态的操作
                scheduleLightAlarmLocked(mNextLightIdleDelay);//600000,5mins
                mLightState = LIGHT_STATE_WAITING_FOR_NETWORK;
                EventLogTags.writeDeviceIdleLight(mLightState, reason);
            }
            break;
    }
}

从代码中可以看到，case为LIGHT_STATE_INACTIVE的处理逻辑中，做了这几件事

  1. 将当前状态设置为LIGHT_STATE_PRE_IDLE，

  2. 并发送一个3分钟的闹钟，准备进入下一个状态。

后续状态也全部是通过scheduleLightAlarmLocked来设置定时任务，然后在stepLightIdleStateLocked函数中处理状态的转换和对应状态的逻辑

2. 从LIGHT_STATE_PRE_IDLE进入LIGHT_STATE_IDLE
3. 从LIGHT_STATE_IDLE_MAINTENANCE进入LIGHT_STATE_IDLE

LIGHT_STATE_PRE_IDLE和LIGHT_STATE_IDLE_MAINTENANCE的下一个状态都是LIGHT_STATE_IDLE，所以他们的处理也在同一个入口

LIGHT_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_IDLE_TIMEOUT,
        !COMPRESS_TIME ? 5 * 60 * 1000L : 15 * 1000L);

LIGHT_MAX_IDLE_TIMEOUT = mParser.getDurationMillis(KEY_LIGHT_MAX_IDLE_TIMEOUT,
                !COMPRESS_TIME ? 15 * 60 * 1000L : 60 * 1000L);

void stepLightIdleStateLocked(String reason) {
    //如果mLigthSate为LIGHT_STATE_OVERRIDE,说明DeepDoze处于Idle状态，由
    // DeepDoze将LightDoze覆盖了，因此不需要进行LightDoze了
    if (mLightState == LIGHT_STATE_OVERRIDE) {
        return;
    }
    switch (mLightState) {
        ……
        case LIGHT_STATE_PRE_IDLE:
        case LIGHT_STATE_IDLE_MAINTENANCE:
            if (mMaintenanceStartTime != 0) {
            //维护状态的时长
                long duration = SystemClock.elapsedRealtime() - 
                 mMaintenanceStartTime;
                if (duration < 
                 mConstants.LIGHT_IDLE_MAINTENANCE_MIN_BUDGET) {
                    mCurIdleBudget += (mConstants.LIGHT_IDLE_MAINTENANCE
                       _MIN_BUDGET-duration);
                } else {
                    mCurIdleBudget -= (duration-mConstants.LIGHT_IDLE_
                      MAINTENANCE_MIN_BUDGET);
                }
            }
            mMaintenanceStartTime = 0;//重置维护开始时间
            //设置一个定时器，到达时间后用来处理LightDoze处于IDLE状态的操作
            scheduleLightAlarmLocked(mNextLightIdleDelay);
           //计算下次进入Idle状态的
            mNextLightIdleDelay = 
            Math.min(mConstants.LIGHT_MAX_IDLE_TIMEOUT,
                    (long)(mNextLightIdleDelay * 
                mConstants.LIGHT_IDLE_FACTOR));
            if (mNextLightIdleDelay < mConstants.LIGHT_IDLE_TIMEOUT) {
                mNextLightIdleDelay = mConstants.LIGHT_IDLE_TIMEOUT;
            }
            //将LightDoze模式置为IDLE状态,开始进行一些限制
            mLightState = LIGHT_STATE_IDLE;
            addEvent(EVENT_LIGHT_IDLE);
            //申请一个wakelock锁，保持CPU唤醒
            mGoingIdleWakeLock.acquire();
            //处理LightDoze进入Idle状态后的操作
            mHandler.sendEmptyMessage(MSG_REPORT_IDLE_ON_LIGHT);
            break;
        ……
    }
}

这里会将state设置成LIGHT_STATE_IDLE，并设置一个mNextLightIdleDelay的计时任务，以便进入下一个状态，mNextLightIdleDelay的初始值是5分钟。

这里我们可以看到LIGHT_STATE_PRE_IDLE和LIGHT_STATE_IDLE_MAINTENANCE是同一个case处理逻辑，这两个状态的下一个状态都是LIGHT_STATE_IDLE。

如果上一个状态是LIGHT_STATE_IDLE_MAINTENANCE，则

mNextLightIdleDelay = Math.min(mConstants.LIGHT_MAX_IDLE_TIMEOUT,(long)(mNextLightIdleDelay * mConstants.LIGHT_IDLE_FACTOR))，LIGHT_MAX_IDLE_TIMEOUT为15分钟，LIGHT_IDLE_FACTOR为2

所以light doze的IDLE时间为5分钟，10分钟，最后稳定为15分钟。

当state的状态转换成IDLE后，这里会申请wakelock锁，让cpu唤醒，然后通过MSG_REPORT_IDLE_ON_LIGHT的Handler任务进行逻辑处理，然后再释放wakelock锁，让cpu休眠。

剩下的几种状态函数转换都在上面的函数中有注释，就不详细讲解了。

Doze限制逻辑

我们接着看MSG_REPORT_IDLE_ON_LIGHT中做了哪些事情

case MSG_REPORT_IDLE_ON:
case MSG_REPORT_IDLE_ON_LIGHT:: {
    final boolean deepChanged;
    final boolean lightChanged;
    if (msg.what == MSG_REPORT_IDLE_ON) {
        //通知PMS设置Deep Doze模式处于IDLE状态
        deepChanged = mLocalPowerManager.setDeviceIdleMode(true);
        //通知PMS为Light Doze模式不处于IDLE状态
        lightChanged = mLocalPowerManager.setLightDeviceIdleMode(false);
    } else {
        //通知PMS设置Deep Doze模式不处于IDLE状态
        deepChanged = mLocalPowerManager.setDeviceIdleMode(false);
        //通知PMS为Light Doze模式处于IDLE状态
        lightChanged = mLocalPowerManager.setLightDeviceIdleMode(true);
    }
    try {
        //通知NetworkPolicyManager进入IDLE状态，进行网络访问的限制
        mNetworkPolicyManager.setDeviceIdleMode(true);
        //通知BatteryStatsService统计Light Doze或者Deep Doze进入IDLE状态
        mBatteryStats.noteDeviceIdleMode(msg.what == MSG_REPORT_IDLE_ON
                ? BatteryStats.DEVICE_IDLE_MODE_DEEP
                : BatteryStats.DEVICE_IDLE_MODE_LIGHT, null, Process.myUid());
    } catch (RemoteException e) {
    }
    //发送DeepDoze模式改变的广播
    if (deepChanged) {
        getContext().sendBroadcastAsUser(mIdleIntent, UserHandle.ALL);
    }
    //发送Light模式改变的广播
    if (lightChanged) {
        getContext().sendBroadcastAsUser(mLightIdleIntent, UserHandle.ALL);
    }
    //释放wakelock
    mGoingIdleWakeLock.release();
} break;

可以看到，Deep Doze和Light Doze在进入IDLE状态后的逻辑处理在同一个地方。这里根据模式的不同，通知PowerServiceManager，NetworkPolicyManager，BatteryStats等进行不同的优化策略。这里主要做的事情有这几件

  1. 调用mLocalPowerManager.setDeviceIdleMode设置是否是Deep Doze的Idle状态，如果为Idle，这一步会将应用设置成忽略WakeLock的状态

  2. 调用mLocalPowerManager.setLightDeviceIdleMode设置是否是Light Doze的Idle状态

  3. 调用mNetworkPolicyManager.setDeviceIdleMode(true)，通过添加防火墙规则，来进行网络访问限制

  4. 调用BatteryStats.noteDeviceIdleMode进行状态变更及耗时统计

  5. 调用sendBroadcastAsUser发送广播，进入Deep Doze或者Light Doze的Idle状态

  6. 释放WakeLock

Doze限制逻辑取消

Light Doze和Deep Doze进入MAINTENCANCE后都会取消各种限制，取消的逻辑在MSG_REPORT_IDLE_OFF的handler任务中处理。

case MSG_REPORT_IDLE_OFF: {
    // mActiveIdleWakeLock is held at this point
    EventLogTags.writeDeviceIdleOffStart("unknown");
    final boolean deepChanged = mLocalPowerManager.setDeviceIdleMode(false);
    final boolean lightChanged = mLocalPowerManager.setLightDeviceIdleMode(false);
    try {
        mNetworkPolicyManager.setDeviceIdleMode(false);
        mBatteryStats.noteDeviceIdleMode(BatteryStats.DEVICE_IDLE_MODE_OFF,
                null, Process.myUid());
    } catch (RemoteException e) {
    }
    if (deepChanged) {
        incActiveIdleOps();
        getContext().sendOrderedBroadcastAsUser(mIdleIntent, UserHandle.ALL,
                null, mIdleStartedDoneReceiver, null, 0, null, null);
    }
    if (lightChanged) {
        incActiveIdleOps();
        getContext().sendOrderedBroadcastAsUser(mLightIdleIntent, UserHandle.ALL,
                null, mIdleStartedDoneReceiver, null, 0, null, null);
    }
    decActiveIdleOps();
} break;

Standby模式

Doze模式是针对整个系统的耗电优化模式，而Standby模式，即应用群组待机模式是针对单个应用的耗电优化模式，它是Android7.0引入的，当应用处于闲置状态时，系统会根据应用应用最近使用的时间和频率，设置成对应的群组，不同的群组下，jobs，alarm和network的使用限制程度不一样。

Standby模式的进入和退出

当用户有一段时间未触摸应用时，系统便会判断进入Standby模式，以下条件下不适用或者会退出Standby模式：

  1. 用户主动启动该App;

  2. 该App当前有一个前台进程（或包含一个活动的前台服务，或被另一个activity或前台service使用）;

  3. 在锁定屏幕或通知栏中看到的通知

  4. 系统应用

  5. 充电状态

Standby模式优化策略

应用在进入Standby后，会根据该应用所属的状态，对Jobs，Alarms和Network进行相应的限制，应用的状态分为五个等级

  1. Activie:如果用户当前正在使用应用，应用将被归到“atcitive”状态中

  2. WORKING_SER：如果应用经常运行(12至24小时内使用过)，但当前未处于活跃状态，它将被归到“工作集”群组中。 例如，用户在大部分时间都启动的某个社交媒体应用可能就属于“工作集”群组。 如果应用被间接使用，它们也会被升级到“工作集”群组中 。

  3. FREQUENT：如果应用会定期使用，但不是每天都必须使用 （亮屏时间差超过1小时、使用时间差超过24小时） ，它将被归到“常用”群组中。 例如，用户在健身房运行的某个锻炼跟踪应用可能就属于“常用”群组。

  4. RARE：如果应用不经常使用 (亮屏时间差超过2小时、使用时间差超过48小时) ，那么它属于“极少使用”群组。 例如，用户仅在入住酒店期间运行的酒店应用就可能属于“极少使用”群组。如果应用处于“极少使用”群组，系统将对它运行作业、触发警报和接收高优先级 FCM 消息的能力施加严格限制。系统还会限制应用连接到网络的能力。

  5. NEVER：安装但是从未运行过的应用会被归到“从未使用”群组中。 系统会对这些应用施加极强的限制。

下面是对这个五个等级的应用的限制情况

developer.android.com/topic/perfo…

Standby模式实现原理

Standby模式的逻辑实现在AppStandbyController对象中，该对象提供了reportEvent，来让外部进行app行为变化的通知，如ams，NotificationManagerService等都会调用reportEvent来告知app有行为变化并更新Bucket

AppStandbyController.java

更新Bucket

void reportEvent(UsageEvents.Event event, long elapsedRealtime, int userId) {
    if (!mAppIdleEnabled) return;
    synchronized (mAppIdleLock) {
        // TODO: Ideally this should call isAppIdleFiltered() to avoid calling back
        // about apps that are on some kind of whitelist anyway.
        final boolean previouslyIdle = mAppIdleHistory.isIdle(
                event.mPackage, userId, elapsedRealtime);
        // Inform listeners if necessary
        if ((event.mEventType == UsageEvents.Event.ACTIVITY_RESUMED
                || event.mEventType == UsageEvents.Event.ACTIVITY_PAUSED
                || event.mEventType == UsageEvents.Event.SYSTEM_INTERACTION
                || event.mEventType == UsageEvents.Event.USER_INTERACTION
                || event.mEventType == UsageEvents.Event.NOTIFICATION_SEEN
                || event.mEventType == UsageEvents.Event.SLICE_PINNED
                || event.mEventType == UsageEvents.Event.SLICE_PINNED_PRIV
                || event.mEventType == UsageEvents.Event.FOREGROUND_SERVICE_START)) {

            final AppUsageHistory appHistory = mAppIdleHistory.getAppUsageHistory(
                    event.mPackage, userId, elapsedRealtime);
            final int prevBucket = appHistory.currentBucket;
            final int prevBucketReason = appHistory.bucketingReason;
            final long nextCheckTime;
            final int subReason = usageEventToSubReason(event.mEventType);
            final int reason = REASON_MAIN_USAGE | subReason;

            //根据使用行为更新bucket
            if (event.mEventType == UsageEvents.Event.NOTIFICATION_SEEN
                    || event.mEventType == UsageEvents.Event.SLICE_PINNED) {
                mAppIdleHistory.reportUsage(appHistory, event.mPackage,
                        STANDBY_BUCKET_WORKING_SET, subReason,
                        0, elapsedRealtime + mNotificationSeenTimeoutMillis);
                nextCheckTime = mNotificationSeenTimeoutMillis;
            } else if (event.mEventType == UsageEvents.Event.SYSTEM_INTERACTION) {
                mAppIdleHistory.reportUsage(appHistory, event.mPackage,
                        STANDBY_BUCKET_ACTIVE, subReason,
                        0, elapsedRealtime + mSystemInteractionTimeoutMillis);
                nextCheckTime = mSystemInteractionTimeoutMillis;
            } else if (event.mEventType == UsageEvents.Event.FOREGROUND_SERVICE_START) {
                // Only elevate bucket if this is the first usage of the app
                if (prevBucket != STANDBY_BUCKET_NEVER) return;
                mAppIdleHistory.reportUsage(appHistory, event.mPackage,
                        STANDBY_BUCKET_ACTIVE, subReason,
                        0, elapsedRealtime + mInitialForegroundServiceStartTimeoutMillis);
                nextCheckTime = mInitialForegroundServiceStartTimeoutMillis;
            } else {
                mAppIdleHistory.reportUsage(appHistory, event.mPackage,
                        STANDBY_BUCKET_ACTIVE, subReason,
                        elapsedRealtime, elapsedRealtime + mStrongUsageTimeoutMillis);
                nextCheckTime = mStrongUsageTimeoutMillis;
            }
            //设置延时消息，根据使用时间更新bucket
            mHandler.sendMessageDelayed(mHandler.obtainMessage
                    (MSG_CHECK_PACKAGE_IDLE_STATE, userId, -1, event.mPackage),
                    nextCheckTime);
            final boolean userStartedInteracting =
                    appHistory.currentBucket == STANDBY_BUCKET_ACTIVE &&
                    prevBucket != appHistory.currentBucket &&
                    (prevBucketReason & REASON_MAIN_MASK) != REASON_MAIN_USAGE;
            maybeInformListeners(event.mPackage, userId, elapsedRealtime,
                    appHistory.currentBucket, reason, userStartedInteracting);

            if (previouslyIdle) {
                notifyBatteryStats(event.mPackage, userId, false);
            }
        }
    }
}

reportEvent会根据mEventType进行一次Bucket更新，并根据mEventType设置一次延时任务，这个延时任务中会再次根据应用的使用行为再次更新Bucket。其中Notification类型的消息的延迟时间为12小时，SYSTEM_INTERACTION为10分钟，其他的mStrongUsageTimeoutMillis为1小时

MSG_CHECK_PACKAGE_IDLE_STATE的handler消息主要根据使用时长更新Bucket

static final int[] THRESHOLD_BUCKETS = {
        STANDBY_BUCKET_ACTIVE,
        STANDBY_BUCKET_WORKING_SET,
        STANDBY_BUCKET_FREQUENT,
        STANDBY_BUCKET_RARE
};

static final long[] SCREEN_TIME_THRESHOLDS = {
        0,
        0,
        COMPRESS_TIME ? 120 * 1000 : 1 * ONE_HOUR,
        COMPRESS_TIME ? 240 * 1000 : 2 * ONE_HOUR
};

static final long[] ELAPSED_TIME_THRESHOLDS = {
        0,
        COMPRESS_TIME ?  1 * ONE_MINUTE : 12 * ONE_HOUR,
        COMPRESS_TIME ?  4 * ONE_MINUTE : 24 * ONE_HOUR,
        COMPRESS_TIME ? 16 * ONE_MINUTE : 48 * ONE_HOUR
};

long[] mAppStandbyScreenThresholds = SCREEN_TIME_THRESHOLDS;
long[] mAppStandbyElapsedThresholds = ELAPSED_TIME_THRESHOLDS;

@StandbyBuckets int getBucketForLocked(String packageName, int userId,
        long elapsedRealtime) {
    int bucketIndex = mAppIdleHistory.getThresholdIndex(packageName, userId,
            elapsedRealtime, mAppStandbyScreenThresholds, mAppStandbyElapsedThresholds);
    return THRESHOLD_BUCKETS[bucketIndex];
}

AppIdleHistory.java

int getThresholdIndex(String packageName, int userId, long elapsedRealtime,
        long[] screenTimeThresholds, long[] elapsedTimeThresholds) {
    ArrayMap userHistory = getUserHistory(userId);
    AppUsageHistory appUsageHistory = getPackageHistory(userHistory, packageName,
            elapsedRealtime, false);
    if (appUsageHistory == null) return screenTimeThresholds.length - 1;

    //app最后一次亮屏使用到现在,已经有多久的亮屏时间
    long screenOnDelta = getScreenOnTime(elapsedRealtime) - appUsageHistory.lastUsedScreenTime;
    //app最后一次使用到现在的时间点
    long elapsedDelta = getElapsedTime(elapsedRealtime) - appUsageHistory.lastUsedElapsedTime;
    for (int i = screenTimeThresholds.length - 1; i >= 0; i--) {
        if (screenOnDelta >= screenTimeThresholds[i]
            && elapsedDelta >= elapsedTimeThresholds[i]) {
            return i;
        }
    }
    return 0;
}

App耗电分析

Battery Historian

Android官方提供了Battery Historian来进行电量使用的分析，Battery Historian 图表会显示一段时间内与电源相关的事件。

从上面的图也可以看到，进入到Doze后，BLE scanning，GPS等就无行为了，并且cpu，wakelock等活动的频率也变低了

我们还能通过Battery Historian获取应用的

  • 在设备上的估计耗电量。

  • 网络信息。

  • 唤醒锁定次数。

  • 服务

  • 进程信息

官方文档已经讲的非常详细，就不在这儿细说了

developer.android.com/topic/perfo…

Slardar

Slardar电量相关的统计指标项包括

  • app处于前台时，提供电流作为耗电指标

  • 通过采集app的cpu、流量和gps等的使用，来计算出一个加权和作为耗电指标

  • 电池温度，作为衡量耗电的辅助参考

归因项有

  • 高CPU可以通过cpu菜单查看高耗CPU的堆栈

  • gps(location),alarm和wakelock使用在超过指定持有时间和频次后，会上报当时的采集堆栈

虽然Slardar有上报很多功耗相关指标，但是目前还只能作为整体功耗的参考，并且很多指标波动起伏大，没法对更细化的治理提供帮助

飞书耗电治理

治理目标

  1. 消除主流手机的高功耗提醒

  2. 建立健全的功耗监控及防劣化体系

治理方案

在前面我们已经知道耗电=模块功率✖️模块耗时，所以治理本质就是在不影响性能和功能的情况下，减少飞书中所使用到的模块的耗时，并且我们了解了系统进行耗电优化的策略，在飞书的耗电治理中，也可以同样的参考对应的策略。

治理方案主要分为监控的完善和耗电的治理

功耗治理

为了能体系化的进行功耗治理，这里分为了针对耗电模块进行治理和针对状态进行执行两大类

分模块治理

模块的耗电治理主要体现在下面几个方面

  • 1.CPU
    • 死循环函数，高频函数，高耗时函数，无效函数等不必要的cpu消耗或消耗较多的函数治理
    • cpu使用率较高的场景及业务治理
  • 2.GPU和Display
    • 过度绘制，过多的动画，不可见区域的动画等浪费GPU的场景治理
    • 主动降低屏幕亮度，使用深色UI等方案降低屏幕电量消耗
  • 3.网络
    • 不影响业务和性能前提下，降低网络访问频率
    • Doze状态时减少无效的网络请求
  • 4.GPS
    • 对使用GPS的场景，如小程序等，合理的降低精度，减少请求频率
  • 5.Audio、Camera、Video等项

除了分模块治理，还针对状态进行治理，主要状态有这几种

分状态治理

1.前台状态

  • 渲染场景优化

  • 音视频等场景优化

  • ……

2.后台状态

  • task任务降频或者丢弃

  • 网络访问降频，适配Doze模式

  • 减少cpu消耗较多的函数执行

  • 减少gps等高功耗场景

完善功耗分析和监控体系

为了能更好的进行治理，完善的功耗分析和监控体系是不可避免的，不然就会出现无的放矢的状态。在这一块主要建设的点有

  • 1. 完善的CPU消耗监控

    • 前后台高cpu消耗场景监控，高cpu消耗线程监控(slardar已有)
    • 高频task，高耗时task，后台task监控(已有)
    • 消耗较高，耗时较高的函数监控

  • 2. GPU和Display消耗监控

    • 动画场景，过度绘制检测，View层级检测，屏幕电量消耗监控等

  • 3. 网络

    • Rust，OkHttp及其他网络请求场景，频率，消耗监控
    • 后台网络访问监控

  • 4. GPS

    • GPS使用场景，时长，电量消耗监控

  • 5. Audio、Camera、Video

    • 使用场景，时长，电量消耗监控

  • 6. 整体和场景的电量消耗

    • 飞书整体的电量消耗和不同场景的电量消耗，用来度量版本功耗的质量

作者：helson赵子健
链接：https://juejin.cn/post/7165802603870158855

你可能感兴趣的:(Android耗电原理及飞书耗电治理)

  • Android和IOS应用开发-Flutter应用让屏幕在 app 运行期间保持常亮的方法 江上清风山间明月 FlutterandroidiosflutterKeepAlive屏幕常亮wakelock熄屏
    文章目录Flutter应用让屏幕在app运行期间保持常亮的方法方法一：使用系统插件方法二：使用Widgets注意事项Flutter应用让屏幕在app运行期间保持常亮的方法在Flutter开发中，可以使用以下两种方法让屏幕在app运行期间保持常亮：方法一：使用系统插件Flutter社区中已经有很多相关插件可供使用，比如wakelock:https://pub.dev/packages/wakeloc
  • 数据结构奇妙旅程之深入解析快速排序 山间漫步人生路 数据结构排序算法算法
    快速排序（QuickSort）是一种高效的排序算法，它使用了分治法的策略来将一个数组排序。其基本思想是选择一个基准元素，通过一趟排序将待排序的数据分割成独立的两部分，其中一部分的所有数据都比基准元素小，另一部分的所有数据都比基准元素大，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。工作原理选择基准：从待排序的序列中选一个元素作为基准（pivo
  • android 自定义曲线图,Android自定义View——贝赛尔曲线 weixin_39767513 android自定义曲线图
    个人博客：haichenyi.com。感谢关注本文针对有一定自定义View的童鞋，最好对贝赛尔曲线有辣么一丢丢了解，不了解也没关系。花5分钟看一下GcsSloop的安卓自定义View进阶-Path之贝塞尔曲线。本文的最终效果图：最终效果图.gif思路首先他是一个只有上半部分的正弦形状的水波纹，很规则。其次，他这个正弦图左右在移动。然后，就是它这个自定义View，上下也在移动，是慢慢增加的最后，优化
  • Flink中的SQL Client和SQL Gateway BigDataMLApplication flinkflinksqlgateway
    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
  • 2022年河南省高等职业教育技能大赛云计算赛项竞赛赛卷（样卷） 忘川_ydy 云计算云计算openstackkubernetesdockerpythonk8sansible
    #需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！#需要资源（软件包及镜像）或有问题的，可私博主！！！第一部分：私有云任务1私有云服务搭建(10分)使用提供的用户名密码，登录竞赛用的云计算平台，按要求自行使用镜像创建两台云主机，创建完云主机后确保网络正常通信，然后按要求配置服务器。根据提供安装脚本框架，补充脚本完成OpenStack平台的安装搭
  • word字号和mathtype磅值关系及批量修改 小铁匠-Ma office小技巧经验分享
    word字号和mathtype磅值关系及批量修改1.字号与磅值关系字号「八号」对应磅值5字号「七号」对应磅值5.5字号「小六」对应磅值6.5字号「六号」对应磅值7.5字号「小五」对应磅值9字号「五号」对应磅值10.5字号「小四」对应磅值12字号「四号」对应磅值14字号「小三」对应磅值15字号「三号」对应磅值16字号「小二」对应磅值18字号「二号」对应磅值22字号「小一」对应磅值24字号「一号」对应
  • Mac命令行查找SDK/JDK安装位置 iblade Linuxmacosjava开发语言
    要在命令行中查询AndroidSDKPlatformTools的安装位置，可以使用以下步骤：使用which命令：在命令行中执行以下命令：whichadb这将输出adb命令的安装路径，通常情况下，它会在AndroidSDK的platform-tools目录下。手动查找：如果whichadb没有输出，可以手动查找AndroidSDK的安装位置。通常情况下，AndroidSDK的默认安装路径是在用户的h
  • 下载Android源码 赛非斯
    repoinit-uhttps://mirrors.tuna.tsinghua.edu.cn/git/AOSP/platform/manifest-bandroid-10.0.0_r411.首先下载repo：a）终端运行gitclonegit://codeaurora.org/tools/repo.gitb）mkdir~/binc）拷贝repo到~/bin下面，修改repo权限，chmoda+x~
  • 以前开发MFC界面如何快速转成QT界面 广州视觉芯软件有限公司 mfcqtc++
    将MFC界面快速转换为Qt界面可能需要进行一些手动工作，因为MFC和Qt是两个不同的界面框架，它们具有不同的设计和实现原理。但是，以下步骤可以帮助你快速进行转换：创建一个新的Qt项目：使用QtCreator创建一个新的Qt项目。分析MFC界面：仔细分析你的MFC界面，包括窗口、对话框、控件等的布局、样式和行为。重新设计界面：使用Qt的可视化设计器重新设计界面。在QtCreator的设计器中，你可以
  • 1.计算机处理器架构+嵌入式处理器架构及知识 vv 啊 arm-linux学习linux系统架构
    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
  • 读史明智：龚遂展现了循吏的操守和能力 逆熵成长
    网图侵删读《资治通鉴·汉纪十七》和《汉书·循吏传》，看到历经刘贺、刘病已两任老板的龚遂，都得到了老板信任。对昏庸无能的刘贺，坚持操守敢于直言；在宣帝重用时，有勇有谋，让百姓饥馑，盗贼并起的渤海得到了治理，从中可见循吏的本色。01多次力谏刘贺，终免一死龚遂因通晓经术而担任官职，官至昌邑国郎中令，侍奉昌邑王刘贺。刘贺行为不端，龚遂为人忠厚，性格刚毅临难不苟，他在府内规劝刘贺，在府外指责傅相，援引经义，
  • 谷歌浏览器驱动Chromedriver（114-120版本）文件以及驱动下载教程 pigerr杨 Pythonpythonchromedrivers
    ChromeDriver官方网站GitHub||GoogleChromeLabs/chrome-for-testingChromeDriver113-125_JSONChromeforTestingavailability123-125zip白月黑羽Python基础|进阶|Qt图形界面|Django|自动化测试|性能测试|JS语言|JS前端|原理与安装
  • 关于举办第十五届蓝桥杯全国软件和信息技术专业人才大赛项目实战赛的通知 QSNKJJSW 蓝桥杯职场和发展青少年编程无人机机器人科技人工智能
    各高等院校及相关单位：为贯彻落实《中国教育现代化2035》和《国务院关于印发新时期促进集成电路产业和软件产业高质量发展若干政策的通知》有关精神，为我国制造强国和网络强国战略提供人才支持，提高学生自主创新意识和工程实践能力，工业和信息化部人才交流中心决定举办第十五届蓝桥杯全国软件和信息技术专业人才大赛——项目实战赛。大赛连续四年入围中国高等教育学会“全国普通高校大学生竞赛排行榜”竞赛项目榜单。现将项
  • flutter 修改app名字和图标 肥肥呀呀呀 flutter
    一、修改名字在Android中修改应用程序名称：在AndroidManifest.xml文件中修改应用程序名称：打开Flutter项目中的android/app/src/main/AndroidManifest.xml文件。找到标签，然后在android:label属性中修改应用程序的名称，例如：android:label="YourNewAppName"。在strings.xml文件中修改应用程
  • max_element()和min_element()函数及用法介绍 藕粉和藕片 数据结构c++
    头文件：algorithminta[]={1,4,7,2,8,9,3,5};1.max_element（first,last）作用：返回数组区间[first，last）中最大元素的位置用法：intt=max_element(a,a+8)-a;//注意要减去a本身的地址cout<
  • python清华大学出版社答案_Python机器学习及实践 weixin_39805119 python清华大学出版社答案
    第1章机器学习的基础知识1.1何谓机器学习1.1.1传感器和海量数据1.1.2机器学习的重要性1.1.3机器学习的表现1.1.4机器学习的主要任务1.1.5选择合适的算法1.1.6机器学习程序的步骤1.2综合分类1.3推荐系统和深度学习1.3.1推荐系统1.3.2深度学习1.4何为Python1.4.1使用Python软件的由来1.4.2为什么使用Python1.4.3Python设计定位1.4.
  • 安卓笔记本 - Handler Message MessageQueue Looper SocialException
    不爱写字，一张图解决。Handler,Message,MessageQueue,Looper工作原理
  • linux安装docker及docker-compose 部署spring boot项目 时而有事儿 dockerlinuxdockerlinuxspringboot
    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
  • 自动化测试 —— Pytest fixture及conftest详解 咖啡加剁椒③ 软件测试pytest功能测试软件测试自动化测试程序人生职场和发展
    前言fixture是在测试函数运行前后，由pytest执行的外壳函数。fixture中的代码可以定制，满足多变的测试需求，包括定义传入测试中的数据集、配置测试前系统的初始状态、为批量测试提供数据源等等。fixture是pytest的精髓所在，类似unittest中setup/teardown，但是比它们要强大、灵活很多，它的优势是可以跨文件共享。一、Pytestfixture1.pytestfix
  • k8s入门到实战（十）—— CronJob详细介绍及使用示例 一弓虽 k8s学习kubernetes容器云原生
    CronJob什么是CronJob在k8s中，CronJob是一种用于定期执行任务的资源对象。它基于Cron表达式，允许您在指定的时间间隔内自动运行容器化的任务。CronJob可以定义以下属性：schedule：指定任务执行的时间表，使用标准的Cron表达式语法。例如，“0****”表示每小时执行一次任务。jobTemplate：定义要执行的任务的模板，通常是一个Pod模板。这个模板包含了任务所需
  • Java中HashMap底层数据结构及主要参数? 山间漫步人生路 java数据结构开发语言
    在Java中，HashMap的底层数据结构主要基于数组和链表，同时在Java8及以后的版本中，当链表长度超过一定阈值时，链表会转换为红黑树来优化性能。这种结构结合了数组和链表的优点，既提供了快速的随机访问，又允许动态地扩展存储桶的大小。HashMap的主要参数包括：初始容量（InitialCapacity）：这是HashMap在创建时设定的桶数组的大小。默认值为16。这个值可以根据预计存储的键值对
  • Android 系统应用 pk8签名文件转jks或keystore教程 蜗牛、Z AOSPandroidFrameworkandroidaosp系统应用开发
    一、介绍签名文件对于我们在做应用开发中，经常遇到，且签名文件不仅仅是保护应用安全，还会涉及到应用与底层之间的数据共享和API文件等问题。在Android中，签名文件同样也存在这个问题。但是android中又区分系统应用和普通应用。系统应用可以通过android:sharedUserId="android.uid.system"同享系统uid，可以获取更高的权限。所以在做系统应用开发的时候，经常需要
  • Java学习笔记01 .wsy. 日常java学习笔记
    1.1Java简介Java的前身是Oak，詹姆斯·高斯林是java之父。1.2Java体系Java是一种与平台无关的语言，其源代码可以被编译成一种结构中立的中间文件（.class，字节码文件）于Java虚拟机上运行。1.2.3专有名词JDK提供编译、运行Java程序所需要的种种工具及资源。JRE是运行Java所依赖的环境的集合。JVM是一个虚构出来的计算机，通过在实际的计算机上仿真模拟各种计算机功
  • Vue 常见面试题(一) 安生生申 面试题vue.js前端javascript
    目录1、Vue的最大的优势是什么？（必会）2、Vue和jQuery两者之间的区别是什么？（必会）3、MVVM和MVC区别是什么？哪些场景适合？（必会）1、基本定义2、使用场景3、两者之间的区别4、Vue数据双向绑定的原理是什么?（必会）5、Object.defineProperty和Proxy的区别（必会）6、Vue生命周期总共分为几个阶段？（必会）7、第一次加载页面会触发哪几个钩子函数？（必会）
  • 以客户为中心的企业设计（咨询执业笔记） 觉者看世界
    以客户为中心的企业设计（咨询执业笔记）——何伏全案咨询知名专家数字经济大行其道，过剩的风险资本自由流动，股权市场日益强势，这些力量综合在一起，产生出诸多不合理的企业设计。这些事实使得企业设计的再创造越来越需要一种约束力，许多公司和投资者未能熟谙这种约束力，或者未能将其基本原理运用于具体的商业行为中，因此付出了沉重的代价。无利润区的确存在，并且已在全球蔓延，有愈演愈烈之势。它席卷了数以千计的公司，涉
  • 第七章 索引及执行计划，存储引擎 执笔为剑 #MySQL运维篇编辑器mysql
    第七章索引及执行计划，存储引擎1，索引及执行计划1，作用：提供类似书目录的作用，目的是优化查询2，所用的种类（根据算法）B树索引Hash索引R树FulltextGIS3，B树基于不同的查找算法分类介绍B-tree：在范围查询方面提供了更好的性能（>showengines;#存储引擎作用在表上，不同的表可能有不同的存储引擎mysql>select@@default_storage_engine;#查
  • Java面试题：解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用，Java中的多线程是如何实现的，Java垃圾回收机制的基本原理，并讨论常见的垃圾回收算法 杰哥在此 Java系列javajvm算法面试
    Java内存模型与多线程的深入探讨在Java的世界里，内存模型和多线程是开发者必须掌握的核心知识点。它们不仅关系到程序的性能和稳定性，还直接影响到系统的可扩展性和可靠性。下面，我将通过三个面试题，带领大家深入理解Java内存模型、多线程以及并发编程的相关原理和实践。面试题一：请解释JVM的内存结构，并描述堆、栈、方法区在内存结构中的角色和作用。关注点：JVM内存结构的基本组成堆、栈、方法区的功能和
  • 【Linux】PyCharm无法启动报错及解决方法 不是AI python软件操作Linuxlinuxpycharm运维
    一、问题描述如图，笔者试图在Ubuntu18.04虚拟机上运行PyCharm开发工具（已安装，安装过程可以参考我的博客Ubuntu安装PyCharm），无法启动，报错：CannotconnecttoalreadyrunningIDEinstance.Exception:Process2574isstillrunning.报错截图如下：二、解决方法通过报错信息看出，出于某种原因，进程（PID为257
  • Vue 模版编译原理 I will.874 vue.jsjavascript前端
    当我们使用Vue编写完一个组件以后，Vue会根据模版编译一个render函数，调用render函数生成虚拟DOM，然后将虚拟DOM映射成真实DOM当数据发生变化时，Vue会触发更新视图，调用render函数返回新的虚拟DOM，对比新旧虚拟DOM，修改真实DOM，从而更新页面在此期间，有以下4个关键步骤：模版编译。生成渲染函数render执行render函数生成虚拟DOM首次渲染，根据虚拟DOM生成
  • 【Git安装及使用学习笔记】 可可西里啊 零零散散的学习笔记git学习笔记c++qt5
    Git学习笔记Git安装Git创建本地版本库以及提交文件使用Git提交代码到码云使用Git从码云拉取代码参考博客Git安装这里参考Git详细安装教程（详解Git安装过程的每一个步骤）Git创建本地版本库以及提交文件1.查看git版本信息：git--version2.设置对应用户名与邮箱地址gitconfig--globaluser.name"your_usernamegitconfig--glob
  • 对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
    昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
  • android 网络 百合不是茶 网络
    android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来  方便查找   ,  服务器使用的是TomCat   服务器代码;  servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
  • [读书笔记]读法拉第传 comsci 读书笔记
          1831年的时候,一年可以赚到1000英镑的人..应该很少的...       要成为一个科学家,没有足够的资金支持,很多实验都无法完成       但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
  • 随机数的产生 沐刃青蛟 随机数
    c++中阐述随机数的方法有两种：   一是产生假随机数（不管操作多少次，所产生的数都不会改变）          这类随机数是使用了默认的种子值产生的，所以每次都是一样的。   //默认种子 for (int i = 0; i < 5; i++) { cout<<
  • PHP检测函数所在的文件名 IT独行者 PHP函数
    很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。 创建引用脚本。 代码：   [php]   view plain copy // Filename: functions.php    <?php&nbs
  • 银行各系统功能简介 文强chu 金融
    银行各系统功能简介 　 业务系统 核心业务系统 业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等 清分清算系统 以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程 国际结算系
  • Python学习1(pip django 安装以及第一个project) 小桔子 pythondjangopip
        最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！ 第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
  • php 数组 aichenglong PHP排序数组循环多维数组
    1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不  是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
  • 安装python2.7 AILIKES python
    安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp  /opt/soft/Python-2
  • java异常的处理探讨 百合不是茶 JAVA异常
    //java异常  /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常  b,抛出异常  c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常   */   //2，学会使用try-catch-finally来处理异常  
  • getElementsByName实例 bijian1013 element
    实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
  • 探索JUnit4扩展：Runner bijian1013 java单元测试JUnit
            参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。         文章地址：http://www.blogjava.net/jiangshachina/archive/20
  • [MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
    1. 副本集的特性   1)一台主服务器(Primary),多台从服务器(Secondary)   2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作   3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来   2
  • 【Spark八十一】Hive in the spark assembly bit1129 assembly
    Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
  • Nginx问题定位之监控进程异常退出 ronin47
    nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。 比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
  • No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
    方法一：常用方法   关闭XML验证 工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。 方法二：（个人推荐） 添加 内容如下 <?xml version=
  • Netty源码学习-DefaultChannelPipeline bylijinnan netty
    package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
  • MYSQL数据库常用备份及恢复语句 chicony mysql
    备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码 数据库名 > 文件 备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
  • 小白谈谈云计算--基于Google三大论文 CrazyMizzz Google云计算GFS
        之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。     我先说说GFS   &n
  • hadoop 平衡空间设置方法 daizj hadoopbalancer
    在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property>   <name>dfs.balance.bandwidthPerSec</name>     <value>10485760</value>     <description&g
  • Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
      判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。 曾有人在豆瓣评 《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个 程序员图书列表，目的也就是通过读书，让程序员变懒。  程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
  • Android学习之路 dcj3sjt126com Android学习
    转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。 下面说说我学习Android的感受，我学Android首先是看MARS的视
  • java 遍历Map的四种方法 eksliang javaHashMapjava 遍历Map的四种方法
    转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
  • 【精典】数据库相关相关 gengzg 数据库
    package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
  • 自动补全 huyana_town 自动补全
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
  • jquery在线预览PDF文件，打开PDF文件 天梯梦 jquery
    最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。   核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
  • ViewPager刷新单个页面的方法 lovelease androidviewpagertag刷新
      使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
  • 利用按位取反（~）从复合枚举值里清除枚举值 草料场 enum
    以 C# 中的 System.Drawing.FontStyle 为例。   如果需要同时有多种效果， 如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline;   如果需要去除 style 里的某一种效果，
  • Linux系统新手学习的11点建议 刘星宇 编程工作linux脚本
    　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。 　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
  • hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAOHibernate
    /** * <p>方法描述:sql语句查询 返回List<Class> </p> * <p>方法备注: Class 只能是自定义类 </p> * @param calzz * @param sql * @return * <p>创建人：王川</p> * <p>创建时间：Jul
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他