Android oom_adj 详细解读
源码基于：Android R
0. 前言
在博文《oom_adj 内存水位算法剖析》一文中详细的分析了lmkd 中针对 oom_adj 内存水位的计算、使用方法，在博文《oom_adj 更新原理(1)》、《oom_adj 更新原理(2)》中对Android 系统中 oom_adj 的更新原理进行了详细的剖析。通过这几篇博文我们对 oom_adj 有了更深地了解。
本文在之前博文的基础上，剖析代码细节，对每个 oom_adj 的值进行详细地解读。
1. adj 等级
首先如之前几篇博文，还是先把 oom_adj 的值列举出来，下文将对每个 oom_adj 的值进行单独地解读。
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
| ADJ 等级 | 取值 | 说明 |
| UNKNOWN_ADJ | 1001 | 用于特定地方，一般指将要cache进程，不知道确切值 |
| CACHED_APP_MAX_ADJ | 999 | 不可见进程的最大值，进程可以无任何干扰的被杀 |
| CACHED_APP_LMK_FIRST_ADJ | 950 | oom_adj 等级第一个允许被杀的level，不能等于CACHED_APP_MAX_ADJ |
| CACHED_APP_MIN_ADJ | 900 | 不可见进程的最小值 |
| SERVICE_B_ADJ | 800 | B List中的Service（较老的、使用可能性更小） |
| PREVIOUS_APP_ADJ | 700 | 上一个App的进程(往往通过按返回键) |
| HOME_APP_ADJ | 600 | Home进程 |
| SERVICE_ADJ | 500 | app service 进程，杀掉它一般不会有太大的影响 |
| HEAVY_WEIGHT_APP_ADJ | 400 | 后台的重量级进程，system/rootdir/init.rc文件中startup |
| BACKUP_APP_ADJ | 300 | 备份进程，杀掉它不完全致命，但不好 |
| PERCEPTIBLE_LOW_APP_ADJ | 250 | 被用户或系统绑定的进程，比service 要重要，但是如果被杀掉，不会立即影响客户的感官 |
| PERCEPTIBLE_APP_ADJ | 200 | 可感知的进程，如后台music 播放 |
| VISIBLE_APP_ADJ | 100 | 可视进程 |
| PERCEPTIBLE_RECENT_FOREGROUND_APP_ADJ | 50 | recently TOP 进程 |
| FOREGROUND_APP_ADJ | 0 | 前台进程 |
| PERSISTENT_SERVICE_ADJ | -700 | 关联系统的进程或一个常驻进程 |
| PERSISTENT_PROC_ADJ | -800 | 系统常驻进程，例如telephony 绝对不想杀，但不完全致命 |
| SYSTEM_ADJ | -900 | 系统进程 |
| NATIVE_ADJ | -1000 | native 进程，不归系统管理，所以没有oom_adj 适配 |
2. ADJ < 0
在 adj 的分级中 FOREGROUND_APP_ADJ 的值为0，拥有该 adj 的进程为前台进程。系统认为小于 0 的进程为系统中比较重要的进程。如下：
- NATIVE_ADJ(-1000)：是由 init 进程 fork 出来的 native 进程，并不受 system 管控；
- SYSTEM_ADJ(-900)：指 system_server 进程；
- PERSISTENT_PROC_ADJ(-800)：是指在 AndroidManifest.xml 中声明 android:persistent 为 true的系统 (即带有 FLAG_SYSTEM标记) 进程。persistent 进程一般情况下并不会被杀，即便被杀或者发生 crash 系统也会立即重新拉起该进程；
- PERSISTENT_SERVICE_ADJ(-700)：是由函数 startIsolatedProcess() 方式启动的进程，或者是由 system_server 或者 persistent 进程所绑定的 (并且带有 BIND_ABOVE_CLIENT 或 BIND_IMPORTANT) 服务进程；
2.1 SYSTEM_ADJ（-900）
SYSTEM_ADJ 仅指 system_server 进程。在 SystemServer.startBootstrapServices() 过程中会调用 AMS.setSystemProcess()，而该函数中会将system_server 的maxAdj 设置为 SYSTEM_ADJ：
frameworks/base/services/core/java/com/android/server/am/AMS.java
public void setSystemProcess() {
try {
...
synchronized (this) {
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
app.setPersistent(true);
app.pid = app.mPidForCompact = MY_PID;
app.getWindowProcessController().setPid(MY_PID);
app.maxAdj = ProcessList.SYSTEM_ADJ; //----这里设定system_server 的 maxAdj
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
addPidLocked(app);
mProcessList.updateLruProcessLocked(app, false, null);
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
}
}
...
}在调用 updateOomAdjLocked() 函数的时候传入的是一个参数，从博文《oom_adj 更新原理(2)》中的 computeOomAdjLocked() 得知：
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
if (app.maxAdj <= ProcessList.FOREGROUND_APP_ADJ) {
...
app.curAdj = app.maxAdj;
...
}最终的system_server 进程的 adj 被设置为 -900，从 dumpsys meminfo 中也能看到：
153,028K: System
153,028K: system (pid 1143 / adj -900)2.2 PERSISTENT_PROC_ADJ（-800）
PERSISTENT_PROC_ADJ 的进程需要在 AndroidManifest.xml 中声明 android:persistent 属性为 true 的系统 (带有 FLAG_SYSTEM) 进程，又称 persistent 进程。对于 persistent 进程常规情况下是不会被 kill 的，一旦被kill 或者发生 crash，系统也会立即重启拉起该进程。
设定位置：
- ProcessList.newProcessRecordLocked()；
- AMS.addAppLocked()；
在新的application 启动过程中都会调用 newProcessRecordLocked()，甚至包括 system_server 进程，例如 上一节 提到的 setSystemProcess() 函数：
frameworks/base/services/core/java/com/android/server/am/AMS.java
public void setSystemProcess() {
try {
...
synchronized (this) {
ProcessRecord app = mProcessList.newProcessRecordLocked(info, info.processName,
false,
0,
new HostingRecord("system"));
app.setPersistent(true);
app.pid = app.mPidForCompact = MY_PID;
app.getWindowProcessController().setPid(MY_PID);
app.maxAdj = ProcessList.SYSTEM_ADJ; //----这里设定system_server 的 maxAdj
app.makeActive(mSystemThread.getApplicationThread(), mProcessStats);
addPidLocked(app);
mProcessList.updateLruProcessLocked(app, false, null);
updateOomAdjLocked(OomAdjuster.OOM_ADJ_REASON_NONE);
}
}
...
}代码中第一句话就是通过 newProcessRecordLocked() 函数创建 ProcessRecord 对象。
来看下该函数：
frameworks/base/services/core/java/com/android/server/am/ProcessList.java
final ProcessRecord newProcessRecordLocked(ApplicationInfo info, String customProcess,
boolean isolated, int isolatedUid, HostingRecord hostingRecord) {
String proc = customProcess != null ? customProcess : info.processName;
final int userId = UserHandle.getUserId(info.uid);
int uid = info.uid;
if (isolated) {
...
}
final ProcessRecord r = new ProcessRecord(mService, info, proc, uid);
if (!mService.mBooted && !mService.mBooting
&& userId == UserHandle.USER_SYSTEM
&& (info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {
// The system process is initialized to SCHED_GROUP_DEFAULT in init.rc.
r.setCurrentSchedulingGroup(ProcessList.SCHED_GROUP_DEFAULT);
r.setSchedGroup = ProcessList.SCHED_GROUP_DEFAULT;
r.setPersistent(true);
r.maxAdj = ProcessList.PERSISTENT_PROC_ADJ;
}
if (isolated && isolatedUid != 0) {
// Special case for startIsolatedProcess (internal only) - assume the process
// is required by the system server to prevent it being killed.
r.maxAdj = ProcessList.PERSISTENT_SERVICE_ADJ;
}
addProcessNameLocked(r);
return r;
}通过函数得知，只有在 system_server 启动时会被置为 PERSISTENT_PROC_ADJ，但在 setSystemProcess() 最后会将system_server 的 maxAdj 修改为 SYSTEM_ADJ。
如果该进程是 isolated，maxAdj 会被设为 PERSISTENT_SERVICE_ADJ，详细可以查看第 2.3 节。
来看下另一个函数 addAppLocked()：
frameworks/base/services/core/java/com/android/server/am/AMS.java
final ProcessRecord addAppLocked(ApplicationInfo info, String customProcess, boolean isolated,
boolean disableHiddenApiChecks, boolean disableTestApiChecks,
boolean mountExtStorageFull, String abiOverride, int zygotePolicyFlags) {
ProcessRecord app;
if (!isolated) {
app = getProcessRecordLocked(customProcess != null ? customProcess : info.processName,
info.uid, true);
} else {
app = null;
}
if (app == null) {
app = mProcessList.newProcessRecordLocked(info, customProcess, isolated, 0,
new HostingRecord("added application",
customProcess != null ? customProcess : info.processName));
mProcessList.updateLruProcessLocked(app, false, null);
updateOomAdjLocked(app, OomAdjuster.OOM_ADJ_REASON_PROCESS_BEGIN);
}
...
if ((info.flags & PERSISTENT_MASK) == PERSISTENT_MASK) {
app.setPersistent(true);
app.maxAdj = ProcessList.PERSISTENT_PROC_ADJ;
}
if (app.thread == null && mPersistentStartingProcesses.indexOf(app) < 0) {
mPersistentStartingProcesses.add(app);
mProcessList.startProcessLocked(app, new HostingRecord("added application",
customProcess != null ? customProcess : app.processName),
zygotePolicyFlags, disableHiddenApiChecks, disableTestApiChecks,
mountExtStorageFull, abiOverride);
}
return app;
}当 application 的 flag 置 FLAG_SYSTEM | FLAG_PERSISTENT 时，maxAdj 的值才被设为 PERSISENT_PROC_ADJ。
在SystemServer 启动 startOtherServices() 中会调用 AMS.systemReady() 进行boot 的 完成阶段，此处会调用 startPersistentApps()：
frameworks/base/services/core/java/com/android/server/am/AMS.java
void startPersistentApps(int matchFlags) {
if (mFactoryTest == FactoryTest.FACTORY_TEST_LOW_LEVEL) return;
synchronized (this) {
try {
final List apps = AppGlobals.getPackageManager()
.getPersistentApplications(STOCK_PM_FLAGS | matchFlags).getList();
for (ApplicationInfo app : apps) {
if (!"android".equals(app.packageName)) {
addAppLocked(app, null, false, null /* ABI override */,
ZYGOTE_POLICY_FLAG_BATCH_LAUNCH);
}
}
} catch (RemoteException ex) {
}
}
} 这里加载系统的 persistent 进程，调用 addAppLocked() 函数。
2.3 PERSISTENT_SERVICE_ADJ（-700）
PERSISTENT_SERVICE_ADJ 的进程是 startIsolatedProcess() 方式启动的进程，或者是由 system_server 或 persistent 进程所绑定的服务进程。
我们在上一文 newProcessRecordLocked() 中已经提到过了，当进程为 isolated 时，maxAdj 会被设置为 PERSISTENT_SERVICE_ADJ，而newProcessRecordLocked() 触发的流程如下：
AMS.startIsolatedProcess() -> ProcessList.startProcessLocked() ->newProcessRecordLocked()
另外一种就是在 updateOomAdjLocked() 中会调用 computeOomAdjLocked()：
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
int capabilityFromFGS = 0; // capability from foreground service.
for (int is = app.numberOfRunningServices() - 1;
is >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
is--) {
ServiceRecord s = app.getRunningServiceAt(is);
...
ArrayMap> serviceConnections = s.getConnections();
for (int conni = serviceConnections.size() - 1;
conni >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
conni--) {
ArrayList clist = serviceConnections.valueAt(conni);
for (int i = 0;
i < clist.size() && (adj > ProcessList.FOREGROUND_APP_ADJ
|| schedGroup == ProcessList.SCHED_GROUP_BACKGROUND
|| procState > PROCESS_STATE_TOP);
i++) {
...
int clientAdj = client.getCurRawAdj();
int clientProcState = client.getCurRawProcState();
if ((cr.flags & Context.BIND_WAIVE_PRIORITY) == 0) {
...
if (adj > clientAdj) {
if (app.hasShownUi && !app.getCachedIsHomeProcess()
&& clientAdj > ProcessList.PERCEPTIBLE_APP_ADJ) {
if (adj >= ProcessList.CACHED_APP_MIN_ADJ) {
adjType = "cch-bound-ui-services";
}
} else {
int newAdj;
if ((cr.flags&(Context.BIND_ABOVE_CLIENT
|Context.BIND_IMPORTANT)) != 0) {
if (clientAdj >= ProcessList.PERSISTENT_SERVICE_ADJ) {
newAdj = clientAdj;
} else {
newAdj = ProcessList.PERSISTENT_SERVICE_ADJ;
...
}
} 当前进程绑定有client，且当前进程 adj 优先级还没有 client 优先级高时，确定是否设置了 BIND_ABOVE_CLIENT 或 BIND_IMPORTANT 的flags
3. FOREGROUND_APP_ADJ（0）
场景1：满足以下任一条件的进程都属于FOREGROUND_APP_ADJ(0) 优先级：
- 正处于resumed 状态的Activity
- 正执行一个生命周期回调的Service（比如执行onCreate, onStartCommand, onDestroy等）
- 正执行onReceive() 的BroadcastReceiver
- 通过startInstrumentation() 启动的进程
详细代码可以查看博文《oom_adj 更新原理(2)》中的 computeOomAdjLocked() ：
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
boolean foregroundActivities = false;
if (PROCESS_STATE_CUR_TOP == PROCESS_STATE_TOP && app == topApp) {
// The last app on the list is the foreground app.
adj = ProcessList.FOREGROUND_APP_ADJ;
...
} else if (app.runningRemoteAnimation) {
adj = ProcessList.VISIBLE_APP_ADJ;
...
} else if (app.getActiveInstrumentation() != null) {
adj = ProcessList.FOREGROUND_APP_ADJ;
...
} else if (app.getCachedIsReceivingBroadcast(mTmpBroadcastQueue)) {
adj = ProcessList.FOREGROUND_APP_ADJ;
...
} else if (app.executingServices.size() > 0) {
adj = ProcessList.FOREGROUND_APP_ADJ;
...
} else if (app == topApp) {
adj = ProcessList.FOREGROUND_APP_ADJ;
...
} else {
procState = PROCESS_STATE_CACHED_EMPTY;
...
}场景2： 当客户端进程activity里面调用bindService()方法时flags带有BIND_ADJUST_WITH_ACTIVITY参数，并且该activity处于可见状态，则当前服务进程也属于前台进程，源码如下：
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
final ActivityServiceConnectionsHolder a = cr.activity;
if ((cr.flags&Context.BIND_ADJUST_WITH_ACTIVITY) != 0) {
if (a != null && adj > ProcessList.FOREGROUND_APP_ADJ
&& a.isActivityVisible()) {
adj = ProcessList.FOREGROUND_APP_ADJ;
app.setCurRawAdj(adj);场景3： 对于provider进程，还有以下两个条件能成为前台进程：
- 当Provider的客户端进程ADJ<=FOREGROUND_APP_ADJ时，则Provider进程ADJ等于FOREGROUND_APP_ADJ
- 当Provider有外部(非框架)进程依赖，也就是调用了getContentProviderExternal()方法，则ADJ至少等于FOREGROUND_APP_ADJ
4. VISIBLE_APP_ADJ（100）
可见进程：当ActivityRecord的visible=true，也就是Activity可见的进程。
从Android P开始，进一步细化ADJ级别，增加了 VISIBLE_APP_LAYER_MAX(99)，是指VISIBLE_APP_ADJ(100) 跟 PERCEPTIBLE_APP_ADJ(200) 之间有99个槽，则可见级别ADJ的取值范围为[100,199]。 算法会根据其所在task的mLayerRank来调整其ADJ，100加上mLayerRank就等于目标ADJ，layer越大，则ADJ越小。
关于TaskRecord的mLayerRank的计算方式是在updateOomAdjLocked()过程调用ASS的rankTaskLayersIfNeeded() 方法。
当TaskRecord顶部的ActivityRecord为空或者结束或者不可见时，则设置该TaskRecord的mLayerRank等于-1; 每个ActivityDisplay的baseLayer都是从0开始，从最上面的TaskRecord开始，第一个ADJ=100，从上至下依次加1，直到199为上限。
5. PERCEPTIBLE_APP_ADJ（200）
可感知进程：当该进程存在不可见的Activity，但Activity正处于PAUSING、PAUSED、STOPPING状态，则为PERCEPTIBLE_APP_ADJ。
在 computeOomAdjLocked() 函数中对于可感知进程也有专门的计算：
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
/********* 场景 1 **********/
// Examine all activities if not already foreground.
if (!foregroundActivities && app.getCachedHasActivities()) {
app.computeOomAdjFromActivitiesIfNecessary(mTmpComputeOomAdjWindowCallback,
adj, foregroundActivities, procState, schedGroup, appUid, logUid,
PROCESS_STATE_CUR_TOP);
adj = app.mCachedAdj;
...
}
...
/********* 场景 2 **********/
if (adj > ProcessList.PERCEPTIBLE_APP_ADJ
|| procState > PROCESS_STATE_FOREGROUND_SERVICE) {
if (app.hasForegroundServices()) {
// The user is aware of this app, so make it visible.
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_FOREGROUND_SERVICE;
app.adjType = "fg-service";
app.setCached(false);
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
} else if (app.hasOverlayUi()) {
// The process is display an overlay UI.
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_IMPORTANT_FOREGROUND;
app.setCached(false);
app.adjType = "has-overlay-ui";
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}
...
/********* 场景 3 **********/
if (adj > ProcessList.PERCEPTIBLE_APP_ADJ
|| procState > PROCESS_STATE_TRANSIENT_BACKGROUND) {
if (app.forcingToImportant != null) {
adj = ProcessList.PERCEPTIBLE_APP_ADJ;
procState = PROCESS_STATE_TRANSIENT_BACKGROUND;
app.setCached(false);
app.adjType = "force-imp";
app.adjSource = app.forcingToImportant;
schedGroup = ProcessList.SCHED_GROUP_DEFAULT;
}
}场景1：如果不是前台进程，且存在cache activities，则需要继续确定adj
调用 computeOomAdjFromActivitiesIfNecessary()，这里是在计算 oom_adj 时，传入一个 callback，通过 window 来确认activity 处于什么状态 visible 还是PAUSING、STOPPING 或其他状态，并根据状态调用 callback 对应的回调函数。
- visible：adj 如果大于 VISIBLE_APP_ADJ，则会被拉回 VISIBLE_APP_ADJ；
- PAUSING：adj 如果大于 PERCEPTIBLE_APP_ADJ，则会被拉回 PERCEPTIBLE_APP_ADJ；
- STOPPING：adj 如果大于 PERCEPTIBLE_APP_ADJ，则会被拉回 PERCEPTIBLE_APP_ADJ；
场景2：进程拥有前台services 或进程用有 overlay UI
前提调价是进程重要性已经低于可感知级别，或者进程状态级别高于带前台service
拥有前台services，是执行 startForegroundService() 函数了；
hasOverlayUi() 为true，表示非activity 的UI 位于屏幕最顶层，例如显示类型 TYPE_APPLICATION_OVERLAY 的窗口。
场景3：进程forcingToImportant 非空
该值非空，表示执行了 setProcessImportant() 函数，例如 Toast 弹出过程；
6. BACKUP_APP_ADJ（300）
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
final BackupRecord backupTarget = mService.mBackupTargets.get(app.userId);
if (backupTarget != null && app == backupTarget.app) {
// If possible we want to avoid killing apps while they're being backed up
if (adj > ProcessList.BACKUP_APP_ADJ) {
if (DEBUG_BACKUP) Slog.v(TAG_BACKUP, "oom BACKUP_APP_ADJ for " + app);
adj = ProcessList.BACKUP_APP_ADJ;
if (procState > PROCESS_STATE_TRANSIENT_BACKGROUND) {
procState = PROCESS_STATE_TRANSIENT_BACKGROUND;
}
app.adjType = "backup";
app.setCached(false);
}
if (procState > ActivityManager.PROCESS_STATE_BACKUP) {
procState = ActivityManager.PROCESS_STATE_BACKUP;
app.adjType = "backup";
}
}前提条件是 backupTarget 不为空：
- 执行 bindBackupAgent()过程，设置mBackupTarget值；
- 执行clearPendingBackup()或unbindBackupAgent()过程，置空mBackupTarget值；
7. HEAVY_WEIGHT_APP_ADJ（400）
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
//重量级后台进程，把adj和proc_state都拉回到 heavy weight水平
if (app.getCachedIsHeavyWeight()) {
if (adj > ProcessList.HEAVY_WEIGHT_APP_ADJ) {
// We don't want to kill the current heavy-weight process.
adj = ProcessList.HEAVY_WEIGHT_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
app.setCached(false);
app.adjType = "heavy";
}
if (procState > ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
procState = ActivityManager.PROCESS_STATE_HEAVY_WEIGHT;
app.adjType = "heavy";
}
}
- realStartActivityLocked()过程，当应用的privateFlags标识PRIVATE_FLAG_CANT_SAVE_STATE，设置mHeavyWeightProcess值；
- finishHeavyWeightApp(), 置空mHeavyWeightProcess值；
8. HOME_APP_ADJ（600）
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
//HOME 进程，将其拉回HOME_APP_ADJ
if (app.getCachedIsHomeProcess()) {
if (adj > ProcessList.HOME_APP_ADJ) {
// This process is hosting what we currently consider to be the
// home app, so we don't want to let it go into the background.
adj = ProcessList.HOME_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
app.setCached(false);
app.adjType = "home";
}
if (procState > ActivityManager.PROCESS_STATE_HOME) {
procState = ActivityManager.PROCESS_STATE_HOME;
app.adjType = "home";
}
}
当类型为ACTIVITY_TYPE_HOME的应用启动后会设置mHomeProcess，比如桌面APP。
9. PREVIOUS_APP_ADJ（700）
frameworks/base/services/core/java/com/android/server/am/OomAdjuster.java
private final boolean computeOomAdjLocked(ProcessRecord app, int cachedAdj,
ProcessRecord topApp, boolean doingAll, long now, boolean cycleReEval,
boolean computeClients) {
...
/********* 场景 1 **********/
if (app.getCachedIsPreviousProcess() && app.getCachedHasActivities()) {
if (adj > ProcessList.PREVIOUS_APP_ADJ) {
// This was the previous process that showed UI to the user.
// We want to try to keep it around more aggressively, to give
// a good experience around switching between two apps.
adj = ProcessList.PREVIOUS_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
app.setCached(false);
app.adjType = "previous";
}
if (procState > PROCESS_STATE_LAST_ACTIVITY) {
procState = PROCESS_STATE_LAST_ACTIVITY;
app.adjType = "previous";
}
}
...
/********* 场景 2 **********/
if (app.lastProviderTime > 0 &&
(app.lastProviderTime + mConstants.CONTENT_PROVIDER_RETAIN_TIME) > now) {
if (adj > ProcessList.PREVIOUS_APP_ADJ) {
adj = ProcessList.PREVIOUS_APP_ADJ;
schedGroup = ProcessList.SCHED_GROUP_BACKGROUND;
app.setCached(false);
app.adjType = "recent-provider";
}
if (procState > PROCESS_STATE_LAST_ACTIVITY) {
procState = PROCESS_STATE_LAST_ACTIVITY;
app.adjType = "recent-provider";
}
}
在 computeOomAdjLocked() 函数用有两种场景。
场景1：用户上一个使用的包含UI的进程，为了给用户在两个APP之间更好的切换体验，将上一个进程ADJ设置到PREVIOUS_APP_ADJ的档次。 当activityStoppedLocked()过程会更新上一个应用。
场景2： 当 provider进程，上一次使用时间不超过20S的情况下，优先级不低于PREVIOUS_APP_ADJ。provider进程这个是Android 7.0以后新增的逻辑 ，这样做的好处是在内存比较低的情况下避免拥有provider的进程出现颠簸，也就是启动后杀，然后又被拉。