Android进程调度之adj算法

无参方法：updateOomAdjLocked()
一参方法：updateOomAdjLocked(ProcessRecord app)
五参方法：updateOomAdjLocked(ProcessRecord app, int cachedAdj,
    ProcessRecord TOP_APP, boolean doingAll, long now)

final boolean updateOomAdjLocked(ProcessRecord app) {
    //获取栈顶的Activity
    final ActivityRecord TOP_ACT = resumedAppLocked();
    final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null;
    final boolean wasCached = app.cached;

    mAdjSeq++;

    //确保cachedAdj>=9
    final int cachedAdj = app.curRawAdj >= ProcessList.CACHED_APP_MIN_ADJ
            ? app.curRawAdj : ProcessList.UNKNOWN_ADJ;

    //执行五参updateOomAdjLocked【见小节3.3】
    boolean success = updateOomAdjLocked(app, cachedAdj, TOP_APP, false,
            SystemClock.uptimeMillis());

    //当app cached状态改变，或者curRawAdj=16，则执行无参数updateOomAdjLocked【见小节2.3】
    if (wasCached != app.cached || app.curRawAdj == ProcessList.UNKNOWN_ADJ) {
        updateOomAdjLocked();
    }
    return success;
}

private final boolean updateOomAdjLocked(ProcessRecord app, int cachedAdj,
        ProcessRecord TOP_APP, boolean doingAll, long now) {
    if (app.thread == null) {
        return false;
    }
    //【见小节4】
    computeOomAdjLocked(app, cachedAdj, TOP_APP, doingAll, now);

    //【见小节5】
    return applyOomAdjLocked(app, doingAll, now, SystemClock.elapsedRealtime());
}

final void updateOomAdjLocked() {
    //获取栈顶的Activity
    final ActivityRecord TOP_ACT = resumedAppLocked();
    final ProcessRecord TOP_APP = TOP_ACT != null ? TOP_ACT.app : null;
    final long now = SystemClock.uptimeMillis();
    final long nowElapsed = SystemClock.elapsedRealtime();
    final long oldTime = now - ProcessList.MAX_EMPTY_TIME;
    final int N = mLruProcesses.size();

    //重置所有uid记录，把curProcState设置成16(空进程)
    for (int i=mActiveUids.size()-1; i>=0; i--) {
        final UidRecord uidRec = mActiveUids.valueAt(i);
        uidRec.reset();
    }

    mAdjSeq++;
    mNewNumServiceProcs = 0;
    mNewNumAServiceProcs = 0;

    final int emptyProcessLimit;
    final int cachedProcessLimit;
    // mProcessLimit默认值等于32，通过开发者选择可设置，或者厂商会自行调整
    if (mProcessLimit <= 0) {
        emptyProcessLimit = cachedProcessLimit = 0;
    } else if (mProcessLimit == 1) {
        emptyProcessLimit = 1;
        cachedProcessLimit = 0;
    } else {
        //则emptyProcessLimit = 16， cachedProcessLimit = 16
        emptyProcessLimit = ProcessList.computeEmptyProcessLimit(mProcessLimit);
        cachedProcessLimit = mProcessLimit - emptyProcessLimit;
    }

    //经过计算得 numSlots =3
    int numSlots = (ProcessList.CACHED_APP_MAX_ADJ
            - ProcessList.CACHED_APP_MIN_ADJ + 1) / 2;
    int numEmptyProcs = N - mNumNonCachedProcs - mNumCachedHiddenProcs;

    //确保空进程个数不大于cached进程数
    if (numEmptyProcs > cachedProcessLimit) {
        numEmptyProcs = cachedProcessLimit;
    }
    int emptyFactor = numEmptyProcs/numSlots;
    if (emptyFactor < 1) emptyFactor = 1;
    int cachedFactor = (mNumCachedHiddenProcs > 0 ? mNumCachedHiddenProcs : 1)/numSlots;
    if (cachedFactor < 1) cachedFactor = 1;
    int stepCached = 0;
    int stepEmpty = 0;
    int numCached = 0;
    int numEmpty = 0;
    int numTrimming = 0;

    mNumNonCachedProcs = 0;
    mNumCachedHiddenProcs = 0;

    //更新所有进程状态(基于当前状态)
    int curCachedAdj = ProcessList.CACHED_APP_MIN_ADJ;
    int nextCachedAdj = curCachedAdj+1;
    int curEmptyAdj = ProcessList.CACHED_APP_MIN_ADJ;
    int nextEmptyAdj = curEmptyAdj+2;
    ProcessRecord selectedAppRecord = null;
    long serviceLastActivity = 0;
    int numBServices = 0;
    for (int i=N-1; i>=0; i--) {
        ProcessRecord app = mLruProcesses.get(i);
        if (mEnableBServicePropagation && app.serviceb
                && (app.curAdj == ProcessList.SERVICE_B_ADJ)) {
            numBServices++;
            for (int s = app.services.size() - 1; s >= 0; s--) {
                ServiceRecord sr = app.services.valueAt(s);
                //上次活跃时间距离现在小于5s，则不会迁移到BService
                if (SystemClock.uptimeMillis() - sr.lastActivity
                        < mMinBServiceAgingTime) {
                    continue;
                }
                if (serviceLastActivity == 0) {
                    serviceLastActivity = sr.lastActivity;
                    selectedAppRecord = app;
                //记录service上次活动时间最长的那个app
                } else if (sr.lastActivity < serviceLastActivity) {
                    serviceLastActivity = sr.lastActivity;
                    selectedAppRecord = app;
                }
            }
        }

        if (!app.killedByAm && app.thread != null) {
            app.procStateChanged = false;
            //计算app的adj值【见小节4】
            computeOomAdjLocked(app, ProcessList.UNKNOWN_ADJ, TOP_APP, true, now);

            //当进程未分配adj的情况下，更新adj(cached和empty算法是相同的)
            if (app.curAdj >= ProcessList.UNKNOWN_ADJ) {
                switch (app.curProcState) {
                    case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
                    case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
                        //当进程procState=14或15，则设置adj=9;
                        app.curRawAdj = curCachedAdj;
                        app.curAdj = app.modifyRawOomAdj(curCachedAdj);
                        //当前cacheadj不等于下一次cachedadj时
                        if (curCachedAdj != nextCachedAdj) {
                            stepCached++;
                            //当stepCached大于cachedFactor，则将nextCachedAdj赋值给curCachedAdj，
                            // 并且nextCachedAdj加2，nextCachedAdj最大等于15；
                            if (stepCached >= cachedFactor) {
                                stepCached = 0;
                                curCachedAdj = nextCachedAdj;
                                nextCachedAdj += 2;
                                if (nextCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                                    nextCachedAdj = ProcessList.CACHED_APP_MAX_ADJ;
                                }
                            }
                        }
                        break;
                    default:
                        app.curRawAdj = curEmptyAdj;
                        app.curAdj = app.modifyRawOomAdj(curEmptyAdj);
                        //更新curCachedAdj值
                        if (curEmptyAdj != nextEmptyAdj) {
                            stepEmpty++;
                            //当stepEmpty大于emptyFactor，则将nextEmptyAdj赋值给curEmptyAdj，
                            //并且nextEmptyAdj加2，nextEmptyAdj最大等于15；
                            if (stepEmpty >= emptyFactor) {
                                stepEmpty = 0;
                                curEmptyAdj = nextEmptyAdj;
                                nextEmptyAdj += 2;
                                if (nextEmptyAdj > ProcessList.CACHED_APP_MAX_ADJ) {
                                    nextEmptyAdj = ProcessList.CACHED_APP_MAX_ADJ;
                                }
                            }
                        }
                        break;
                }
            }

            //【见小节2.5】
            applyOomAdjLocked(app, true, now, nowElapsed);

            //根据当前进程procState状态来决策
            switch (app.curProcState) {
                case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
                case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
                    mNumCachedHiddenProcs++;
                    numCached++;
                    // 当cached进程超过上限(cachedProcessLimit)，则杀掉该进程
                    if (numCached > cachedProcessLimit) {
                        app.kill("cached #" + numCached, true);
                    }
                    break;
                case ActivityManager.PROCESS_STATE_CACHED_EMPTY:
                    // 当空进程超过上限(TRIM_EMPTY_APPS)，且空闲时间超过30分钟，则杀掉该进程
                    if (numEmpty > ProcessList.TRIM_EMPTY_APPS
                            && app.lastActivityTime < oldTime) {
                        app.kill("empty for "
                                + ((oldTime + ProcessList.MAX_EMPTY_TIME - app.lastActivityTime)
                                / 1000) + "s", true);
                    } else {
                        // 当空进程超过上限(emptyProcessLimit)，则杀掉该进程
                        numEmpty++;
                        if (numEmpty > emptyProcessLimit) {
                            if (!CT_PROTECTED_PROCESS.equals(app.processName))
                                app.kill("empty #" + numEmpty, true);
                        }
                    }
                    break;
                default:
                    mNumNonCachedProcs++;
                    break;
            }

            if (app.isolated && app.services.size() <= 0) {
                //没有services运行的孤立进程，则直接杀掉
                app.kill("isolated not needed", true);
            } else {
                final UidRecord uidRec = app.uidRecord;
                if (uidRec != null && uidRec.curProcState > app.curProcState) {
                    uidRec.curProcState = app.curProcState;
                }
            }

            if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME
                    && !app.killedByAm) {
                numTrimming++;
            }
        }
    }

    //当BServices个数超过上限(mBServiceAppThreshold)，则
    if ((numBServices > mBServiceAppThreshold) && (true == mAllowLowerMemLevel)
            && (selectedAppRecord != null)) {
        ProcessList.setOomAdj(selectedAppRecord.pid, selectedAppRecord.info.uid,
                ProcessList.CACHED_APP_MAX_ADJ);
        selectedAppRecord.setAdj = selectedAppRecord.curAdj;
    }
    mNumServiceProcs = mNewNumServiceProcs;

    //根据CachedAndEmpty个数来调整内存因子memFactor
    final int numCachedAndEmpty = numCached + numEmpty;
    int memFactor;
    if (numCached <= ProcessList.TRIM_CACHED_APPS
            && numEmpty <= ProcessList.TRIM_EMPTY_APPS) {
        if (numCachedAndEmpty <= ProcessList.TRIM_CRITICAL_THRESHOLD) {
            memFactor = ProcessStats.ADJ_MEM_FACTOR_CRITICAL;
        } else if (numCachedAndEmpty <= ProcessList.TRIM_LOW_THRESHOLD) {
            memFactor = ProcessStats.ADJ_MEM_FACTOR_LOW;
        } else {
            memFactor = ProcessStats.ADJ_MEM_FACTOR_MODERATE;
        }
    } else {
        memFactor = ProcessStats.ADJ_MEM_FACTOR_NORMAL;
    }

    if (memFactor > mLastMemoryLevel) {
        if (!mAllowLowerMemLevel || mLruProcesses.size() >= mLastNumProcesses) {
            memFactor = mLastMemoryLevel;
        }
    }
    mLastMemoryLevel = memFactor;
    mLastNumProcesses = mLruProcesses.size();
    boolean allChanged = mProcessStats.setMemFactorLocked(memFactor, !isSleeping(), now);
    final int trackerMemFactor = mProcessStats.getMemFactorLocked();
    //当内存因子不是普通0级别的情况下
    if (memFactor != ProcessStats.ADJ_MEM_FACTOR_NORMAL) {
        if (mLowRamStartTime == 0) {
            mLowRamStartTime = now;
        }
        int step = 0;
        int fgTrimLevel;
        switch (memFactor) {
            case ProcessStats.ADJ_MEM_FACTOR_CRITICAL:
                fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_CRITICAL;
                break;
            case ProcessStats.ADJ_MEM_FACTOR_LOW:
                fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_LOW;
                break;
            default:
                fgTrimLevel = ComponentCallbacks2.TRIM_MEMORY_RUNNING_MODERATE;
                break;
        }
        int factor = numTrimming/3;
        int minFactor = 2;
        if (mHomeProcess != null) minFactor++;
        if (mPreviousProcess != null) minFactor++;
        if (factor < minFactor) factor = minFactor;

        //TRIM_MEMORY_COMPLETE：该进程处于LRU队列的尾部，当进程不足则会杀掉该进程
        int curLevel = ComponentCallbacks2.TRIM_MEMORY_COMPLETE;
        for (int i=N-1; i>=0; i--) {
            ProcessRecord app = mLruProcesses.get(i);
            if (allChanged || app.procStateChanged) {
                setProcessTrackerStateLocked(app, trackerMemFactor, now);
                app.procStateChanged = false;
            }
            //当curProcState > 12且没有被am杀掉的情况；
            if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME
                    && !app.killedByAm) {
                if (app.trimMemoryLevel < curLevel && app.thread != null) {
                    //调度app执行trim memory的操作
                    app.thread.scheduleTrimMemory(curLevel);
                }
                app.trimMemoryLevel = curLevel;
                step++;
                if (step >= factor) {
                    step = 0;
                    switch (curLevel) {
                        case ComponentCallbacks2.TRIM_MEMORY_COMPLETE:
                            curLevel = ComponentCallbacks2.TRIM_MEMORY_MODERATE;
                            break;
                        case ComponentCallbacks2.TRIM_MEMORY_MODERATE:
                            curLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
                            break;
                    }
                }
            } else if (app.curProcState == ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
                if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_BACKGROUND
                        && app.thread != null) {
                    app.thread.scheduleTrimMemory(
                            ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
                }
                app.trimMemoryLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
            } else {
                if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
                        || app.systemNoUi) && app.pendingUiClean) {
                    final int level = ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN;
                    if (app.trimMemoryLevel < level && app.thread != null) {
                        app.thread.scheduleTrimMemory(level);
                    }
                    app.pendingUiClean = false;
                }
                if (app.trimMemoryLevel < fgTrimLevel && app.thread != null) {
                    app.thread.scheduleTrimMemory(fgTrimLevel);
                }
                app.trimMemoryLevel = fgTrimLevel;
            }
        }
    } else {
        if (mLowRamStartTime != 0) {
            mLowRamTimeSinceLastIdle += now - mLowRamStartTime;
            mLowRamStartTime = 0;
        }
        for (int i=N-1; i>=0; i--) {
            ProcessRecord app = mLruProcesses.get(i);
            if (allChanged || app.procStateChanged) {
                setProcessTrackerStateLocked(app, trackerMemFactor, now);
                app.procStateChanged = false;
            }
            if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
                    || app.systemNoUi) && app.pendingUiClean) {
                if (app.trimMemoryLevel < ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN
                        && app.thread != null) {
                    app.thread.scheduleTrimMemory(
                            ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
                }
                app.pendingUiClean = false;
            }
            app.trimMemoryLevel = 0;
        }
    }

    //是否finish activity
    if (mAlwaysFinishActivities) {
        mStackSupervisor.scheduleDestroyAllActivities(null, "always-finish");
    }

    if (allChanged) {
        requestPssAllProcsLocked(now, false, mProcessStats.isMemFactorLowered());
    }

    //更新 uid的改变
    for (int i=mActiveUids.size()-1; i>=0; i--) {
        final UidRecord uidRec = mActiveUids.valueAt(i);
        if (uidRec.setProcState != uidRec.curProcState) {
            uidRec.setProcState = uidRec.curProcState;
            enqueueUidChangeLocked(uidRec, false);
        }
    }
    ...
}

private final int computeOomAdjLocked(ProcessRecord app, int cachedAdj, ProcessRecord TOP_APP,
         boolean doingAll, long now)；

 if (mAdjSeq == app.adjSeq) {
     return app.curRawAdj; //已经调整完成
 }

 // 当进程对象为空时，则设置curProcState=16， curAdj=curRawAdj=15
 if (app.thread == null) {
     app.adjSeq = mAdjSeq;
     app.curSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
     app.curProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY;
     return (app.curAdj=app.curRawAdj=ProcessList.CACHED_APP_MAX_ADJ);
 }

final int activitiesSize = app.activities.size();
 if (app.maxAdj <= ProcessList.FOREGROUND_APP_ADJ) {
     app.adjType = "fixed";
     app.adjSeq = mAdjSeq;
     app.curRawAdj = app.maxAdj;
     app.foregroundActivities = false;
     app.curSchedGroup = Process.THREAD_GROUP_DEFAULT;
     app.curProcState = ActivityManager.PROCESS_STATE_PERSISTENT;

     app.systemNoUi = true;
     //顶部的activity就是当前app，则代表正处于展现UI
     if (app == TOP_APP) {
         app.systemNoUi = false;
     //进程中的activity个数大于0时
     } else if (activitiesSize > 0) {
         for (int j = 0; j < activitiesSize; j++) {
             final ActivityRecord r = app.activities.get(j);
             if (r.visible) {
                 app.systemNoUi = false;
             }
         }
     }
     if (!app.systemNoUi) {
         app.curProcState = ActivityManager.PROCESS_STATE_PERSISTENT_UI;
     }
     return (app.curAdj=app.maxAdj);
 }

 if (app == TOP_APP) {
     adj = ProcessList.FOREGROUND_APP_ADJ;
     schedGroup = Process.THREAD_GROUP_DEFAULT;
     app.adjType = "top-activity";
     foregroundActivities = true;
     procState = PROCESS_STATE_TOP;
     if(app == mHomeProcess) {
         mHomeKilled = false;
         mHomeProcessName = mHomeProcess.processName;
     }
 } else if (app.instrumentationClass != null) {
     adj = ProcessList.FOREGROUND_APP_ADJ;
     schedGroup = Process.THREAD_GROUP_DEFAULT;
     app.adjType = "instrumentation";
     procState = ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
 } else if ((queue = isReceivingBroadcast(app)) != null) {
     adj = ProcessList.FOREGROUND_APP_ADJ;
     schedGroup = (queue == mFgBroadcastQueue)
             ? Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE;
     app.adjType = "broadcast";
     procState = ActivityManager.PROCESS_STATE_RECEIVER;
 } else if (app.executingServices.size() > 0) {
     adj = ProcessList.FOREGROUND_APP_ADJ;
     schedGroup = app.execServicesFg ?
             Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE;
     app.adjType = "exec-service";
     procState = ActivityManager.PROCESS_STATE_SERVICE;
 } else {
     //top app; isReceivingBroadcast；executingServices；
     // 除此之外则为PROCESS_STATE_CACHED_EMPTY
     schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
     adj = cachedAdj;
     procState = ActivityManager.PROCESS_STATE_CACHED_EMPTY;
     app.cached = true;
     app.empty = true;
     app.adjType = "cch-empty";

     if (mHomeKilled && app.processName.equals(mHomeProcessName)) {
         adj = ProcessList.PERSISTENT_PROC_ADJ;
         schedGroup = Process.THREAD_GROUP_DEFAULT;
         app.cached = false;
         app.empty = false;
         app.adjType = "top-activity";
     }
 }

 if (!foregroundActivities && activitiesSize > 0) {
     for (int j = 0; j < activitiesSize; j++) {
         final ActivityRecord r = app.activities.get(j);
         if (r.app != app) {
             continue;
         }
         当activity可见， 则adj=1,procState=2
         if (r.visible) {
             if (adj > ProcessList.VISIBLE_APP_ADJ) {
                 adj = ProcessList.VISIBLE_APP_ADJ;
                 app.adjType = "visible";
             }
             if (procState > PROCESS_STATE_TOP) {
                 procState = PROCESS_STATE_TOP;
             }
             schedGroup = Process.THREAD_GROUP_DEFAULT;
             app.cached = false;
             app.empty = false;
             foregroundActivities = true;
             break;
         当activity正在暂停或者已经暂停， 则adj=2,procState=2
         } else if (r.state == ActivityState.PAUSING || r.state == ActivityState.PAUSED) {
             if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) {
                 adj = ProcessList.PERCEPTIBLE_APP_ADJ;
                 app.adjType = "pausing";
             }
             if (procState > PROCESS_STATE_TOP) {
                 procState = PROCESS_STATE_TOP;
             }
             schedGroup = Process.THREAD_GROUP_DEFAULT;
             app.cached = false;
             app.empty = false;
             foregroundActivities = true;
         当activity正在停止， 则adj=2,procState=13(activity尚未finish)
         } else if (r.state == ActivityState.STOPPING) {
             if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) {
                 adj = ProcessList.PERCEPTIBLE_APP_ADJ;
                 app.adjType = "stopping";
             }

             if (!r.finishing) {
                 if (procState > ActivityManager.PROCESS_STATE_LAST_ACTIVITY) {
                     procState = ActivityManager.PROCESS_STATE_LAST_ACTIVITY;
                 }
             }
             app.cached = false;
             app.empty = false;
             foregroundActivities = true;
         否则procState=14
         } else {
             if (procState > ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) {
                 procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY;
                 app.adjType = "cch-act";
             }
         }
     }
 }

 if (adj > ProcessList.PERCEPTIBLE_APP_ADJ) {
     当存在前台service时，则adj=2, procState=4；
     if (app.foregroundServices) {
         adj = ProcessList.PERCEPTIBLE_APP_ADJ;
         procState = ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE;
         app.cached = false;
         app.adjType = "fg-service";
         schedGroup = Process.THREAD_GROUP_DEFAULT;
     当强制前台时，则adj=2, procState=6；
     } else if (app.forcingToForeground != null) {
         adj = ProcessList.PERCEPTIBLE_APP_ADJ;
         procState = ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND;
         app.cached = false;
         app.adjType = "force-fg";
         app.adjSource = app.forcingToForeground;
         schedGroup = Process.THREAD_GROUP_DEFAULT;
     }
 }

 if (app == mHeavyWeightProcess) {
     if (adj > ProcessList.HEAVY_WEIGHT_APP_ADJ) {
         adj = ProcessList.HEAVY_WEIGHT_APP_ADJ;
         schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
         app.cached = false;
         app.adjType = "heavy";
     }
     if (procState > ActivityManager.PROCESS_STATE_HEAVY_WEIGHT) {
         procState = ActivityManager.PROCESS_STATE_HEAVY_WEIGHT;
     }
 }

 if (app == mHomeProcess) {
     if (adj > ProcessList.HOME_APP_ADJ) {
         adj = ProcessList.HOME_APP_ADJ;
         schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
         app.cached = false;
         app.adjType = "home";
     }
     if (procState > ActivityManager.PROCESS_STATE_HOME) {
         procState = ActivityManager.PROCESS_STATE_HOME;
     }
 }

 if (app == mPreviousProcess && app.activities.size() > 0) {
     if (adj > ProcessList.PREVIOUS_APP_ADJ) {
         adj = ProcessList.PREVIOUS_APP_ADJ;
         schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE;
         app.cached = false;
         app.adjType = "previous";
     }
     if (procState > ActivityManager.PROCESS_STATE_LAST_ACTIVITY) {
         procState = ActivityManager.PROCESS_STATE_LAST_ACTIVITY;
     }
 }

 if (mBackupTarget != null && app == mBackupTarget.app) {
     if (adj > ProcessList.BACKUP_APP_ADJ) {
         adj = ProcessList.BACKUP_APP_ADJ;
         if (procState > ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND) {
             procState = ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND;
         }
         app.adjType = "backup";
         app.cached = false;
     }
     if (procState > ActivityManager.PROCESS_STATE_BACKUP) {
         procState = ActivityManager.PROCESS_STATE_BACKUP;
     }
 }

 // 当client进程处于top，且procState>2时
 if (mayBeTop && procState > ActivityManager.PROCESS_STATE_TOP) {
     switch (procState) {
         case ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND:
         case ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND:
         case ActivityManager.PROCESS_STATE_SERVICE:
             //对于procState=6,7,10时，则设置成3
             procState = ActivityManager.PROCESS_STATE_BOUND_FOREGROUND_SERVICE;
             break;
         default:
             //其他情况，直接设置成2
             procState = ActivityManager.PROCESS_STATE_TOP;
             break;
     }
 }

 //当procState>= 16时，
 if (procState >= ActivityManager.PROCESS_STATE_CACHED_EMPTY) {
     if (app.hasClientActivities) {
         //当进程存在client activity，则设置procState=15；
         procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT;
         app.adjType = "cch-client-act";
     } else if (app.treatLikeActivity) {
         //当进程可以像activity一样对待时，则设置procState=14；
         procState = ActivityManager.PROCESS_STATE_CACHED_ACTIVITY;
         app.adjType = "cch-as-act";
     }
 }

 //当adj = 5时
 if (adj == ProcessList.SERVICE_ADJ) {
     if (doingAll) {
         //当A类Service个数 > service/3时，则加入到B类Service
         app.serviceb = mNewNumAServiceProcs > (mNumServiceProcs/3);
         mNewNumServiceProcs++;
         if (!app.serviceb) {
             //当对于低RAM设备，则把该service直接放入B类Service
             if (mLastMemoryLevel > ProcessStats.ADJ_MEM_FACTOR_NORMAL
                     && app.lastPss >= mProcessList.getCachedRestoreThresholdKb()) {
                 app.serviceHighRam = true;
                 app.serviceb = true;
             } else {
                 mNewNumAServiceProcs++;
             }
         } else {
             app.serviceHighRam = false;
         }
     }
     //调整adj=8
     if (app.serviceb) {
         adj = ProcessList.SERVICE_B_ADJ;
     }
 }
 //将计算得到的adj赋给curRawAdj
 app.curRawAdj = adj;

 //当adj大小上限为maxAdj
 if (adj > app.maxAdj) {
     adj = app.maxAdj;
     if (app.maxAdj <= ProcessList.PERCEPTIBLE_APP_ADJ) {
         schedGroup = Process.THREAD_GROUP_DEFAULT;
     }
 }
 //对于hasAboveClient=true，则降低该进程adj
 app.curAdj = app.modifyRawOomAdj(adj);
 app.curSchedGroup = schedGroup;
 app.curProcState = procState;
 app.foregroundActivities = foregroundActivities;
 //返回进程的curRawAdj
 return app.curRawAdj;  }

private final boolean applyOomAdjLocked(ProcessRecord app, boolean doingAll, long now,
        long nowElapsed) {
    boolean success = true;

    //将curRawAdj赋给setRawAdj
    if (app.curRawAdj != app.setRawAdj) {
        app.setRawAdj = app.curRawAdj;
    }

    if (app.curAdj != app.setAdj) {
        //将adj值 发送给lmkd守护进程
        ProcessList.setOomAdj(app.pid, app.info.uid, app.curAdj);
        app.setAdj = app.curAdj;
    }

    //情况为： waitingToKill
    if (app.setSchedGroup != app.curSchedGroup) {
        app.setSchedGroup = app.curSchedGroup;
        if (app.waitingToKill != null && app.curReceiver == null
                && app.setSchedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE) {
            //杀进程，并设置applyOomAdjLocked过程失败
            app.kill(app.waitingToKill, true);
            success = false;
        } else {
            long oldId = Binder.clearCallingIdentity();
            try {
                //设置进程组信息
                Process.setProcessGroup(app.pid, app.curSchedGroup);
            } catch (Exception e) {
            } finally {
                Binder.restoreCallingIdentity(oldId);
            }
            //调整进程的swappiness值
            Process.setSwappiness(app.pid,
                    app.curSchedGroup <= Process.THREAD_GROUP_BG_NONINTERACTIVE);
        }
    }
    if (app.repForegroundActivities != app.foregroundActivities) {
        app.repForegroundActivities = app.foregroundActivities;
        changes |= ProcessChangeItem.CHANGE_ACTIVITIES;
    }
    if (app.repProcState != app.curProcState) {
        app.repProcState = app.curProcState;
        changes |= ProcessChangeItem.CHANGE_PROCESS_STATE;
        if (app.thread != null) {
            //设置进程状态
            app.thread.setProcessState(app.repProcState);
        }
    }

    if (app.setProcState == ActivityManager.PROCESS_STATE_NONEXISTENT
            || ProcessList.procStatesDifferForMem(app.curProcState, app.setProcState)) {
        app.lastStateTime = now;
        //当setProcState = -1或者curProcState与setProcState值不同时，则计算pss下次时间(参数true)
        app.nextPssTime = ProcessList.computeNextPssTime(app.curProcState, true,
                mTestPssMode, isSleeping(), now);
    } else {
        当前时间超过pss下次时间，则请求统计pss,并计算pss下次时间(参数false)
        if (now > app.nextPssTime || (now > (app.lastPssTime+ProcessList.PSS_MAX_INTERVAL)
                && now > (app.lastStateTime+ProcessList.minTimeFromStateChange(
                mTestPssMode)))) {
            requestPssLocked(app, app.setProcState);
            app.nextPssTime = ProcessList.computeNextPssTime(app.curProcState, false,
                    mTestPssMode, isSleeping(), now);
        }
    }

    if (app.setProcState != app.curProcState) {
        boolean setImportant = app.setProcState < ActivityManager.PROCESS_STATE_SERVICE;
        boolean curImportant = app.curProcState < ActivityManager.PROCESS_STATE_SERVICE;
        if (setImportant && !curImportant) {
            BatteryStatsImpl stats = mBatteryStatsService.getActiveStatistics();
            synchronized (stats) {
                app.lastWakeTime = stats.getProcessWakeTime(app.info.uid,
                        app.pid, nowElapsed);
            }
            app.lastCpuTime = app.curCpuTime;

        }
        maybeUpdateUsageStatsLocked(app, nowElapsed);

        app.setProcState = app.curProcState;
        if (app.setProcState >= ActivityManager.PROCESS_STATE_HOME) {
            app.notCachedSinceIdle = false;
        }
        if (!doingAll) {
            setProcessTrackerStateLocked(app, mProcessStats.getMemFactorLocked(), now);
        } else {
            app.procStateChanged = true;
        }
    } else if (app.reportedInteraction && (nowElapsed-app.interactionEventTime)
            > USAGE_STATS_INTERACTION_INTERVAL) {
        maybeUpdateUsageStatsLocked(app, nowElapsed);
    }

    if (changes != 0) {
        int i = mPendingProcessChanges.size()-1;
        ProcessChangeItem item = null;
        while (i >= 0) {
            item = mPendingProcessChanges.get(i);
            if (item.pid == app.pid) {
                break;
            }
            i--;
        }
        if (i < 0) {
            final int NA = mAvailProcessChanges.size();
            if (NA > 0) {
                item = mAvailProcessChanges.remove(NA-1);
            } else {
                item = new ProcessChangeItem();
            }
            item.changes = 0;
            item.pid = app.pid;
            item.uid = app.info.uid;
            if (mPendingProcessChanges.size() == 0) {
                mUiHandler.obtainMessage(DISPATCH_PROCESSES_CHANGED).sendToTarget();
            }
            mPendingProcessChanges.add(item);
        }
        item.changes |= changes;
        item.processState = app.repProcState;
        item.foregroundActivities = app.repForegroundActivities;
    }

    return success;
}