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<ApplicationInfo> 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<IBinder, ArrayList<ConnectionRecord>> 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<ConnectionRecord> 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的进程出现颠簸，也就是启动后杀，然后又被拉。