Android 进程管理

在Android中，进程（process）的概念被弱化，传统的进程是程序执行的载体，进程退出意味着应用的关闭。但是在Android中进程知识一个运行组件的容器，当系统需要运行一个组件时，启动包含它的进程，当组件不在使用时，进程也会被关闭。例如一个APK文件中的两个service，可以运行在一个进程中，也可以运行在各自的进程中。
虽然在Android的应用开发中，不再强调进程的概念，但是在AMS中，还必须管理和调度进程，AMS对进程的管理，主要体现在两方面：一是动态的调整进程在mLruProcesss列表的位置，二是调整进程oom_adj的值，这两项调整和系统进行自动内存回收有关。当内存不足时，系统会关闭一些进程来释放内存。
系统主要根据进程的oom_adj值来挑选要杀死的进程，oom_adj值越大表示进程越可能被杀死。

1. 启动进程
AMS中启动一个进程调用的是addAppLocked()方法，代码如下：

final ProcessResord addAppLocked（ApplicationInfo info, boolean isolated）{
ProcessRecord app;
//isolated为true表示要启动一个新进程
if(!isolated){
app=getProcessResordLocked(info.processName,info.uid,true);
}else{
app=null;
}
if(app=null){
//创建一个ProcessRecord对象
app=newProcessRecordLocked(info,null,0);
mProcessNames.put(info.processName,app.uid,app);
if(isolated){
mIsolatedProcesses.put(app.uid,app);
}
updateLruProcessLocked(app,false,null);
updateOomAdjLocked();
}
.....
if(app.thred==null&&mPersistentStartingProcesses.indexOf(app)<0){
mPersistentStartingProcesses.add(app);
//启动进程
startProcessLocked(app,"added application",app.processName
abiOverride,null /*entryPoint */,null /*entryPointArgs */);
}
return app;
}

addAppLocked()方法会根据参数参数isolated来决定是否启动一个新进程，如果isoated为true，即使系统中可能已经有一个同名的进程存在，也会再创建一个新锦成。getProcessRecordLocked()方法用来当前运行的进程列表查找进程。newProcessRecordLocked()方法用来创建一个ProcessRecord的数据结构。updateLruProcessLocked方法用来更新运行进程的状态，updateOomAdjLocked()方法用来更新进程的优先级，这两个方法是Process的管理核心。
首先看看startProcessLocked()是启动进程的方法，看看它的代码:

private final void startProcessLocked(ProcessRecord app,String hostingType,String abiOverride){
if(app.pid>0&&app.pid!=MY_PID){
synchronized(mpidSelfLocked){
mPidSelfLocked.remove(app.pid);//把进程id先移除，防止重复
//把消息PROC_START_TIMEOUT_MSG也清除
mHandler.removeMessages(PROC_START_TIMEOUT_MSG,app);
}
app.setpid(0);
}
mProcessOnHold.remove(app);
......
try{
final int uid=app.uid;
int[] gids=null;
intmountExternal=zygote.MOUNT_EXTERNAL_NONE;
if(!app.isolate){
int [] permGids=null;
try{
final PackageManager
pm=mContext.getPackagesManager();
//检查进程权限，确定它是否能看见所有用户的存储空间
if(Enviroment.isExternalStorageEmulated()){
if(pm.checkPermission(.....)){
mountExternal=Zygote.MOUNTEXTERNAL_MULTIUSER_ALL;
else{
mountExternal=Zygote.MOUNTEXTERNAL_MULTIUSER;
}

}
}catch (PackageManager.NameNotFountException e){.}

}
......
//启动应用
Process.ProcessStartResult startResult=Process.start(
app.processName,uid,uid,gids,debugFlags,
mountExternal,app.info.targetSdkVersion,
app.info.seinfo,requiredAbi,instructionSet,
app.infodataDir,entryPointArgs)
.....
synchornized(mPidSelfLocked){
//发送一个定时消息，时间到应用还没启动完成就会出现ANR
this.mPidSelfLocked.put(startResult.pid,app);
if(isActivityProcess){
Message msg=mHandler.obtainMessage(
PROC_START_TIME_OUT_MSG);
msg.obj=app;
mHandler.sendMessageDelayed(msg,startResult
.usingWrapper?PROC_START_WITH_WRAPPER:
PROC_STRAT_TIMEOUT);
}
}
}catch(RuntimeException e){
app.setpid(0);
mBatteryStatsService.noteProcessFinish(
app.processName,app.info.uid);
if(app.isolated){
mBatteryStatsService.removeIsolatedUid(
app.uid,app.info.uid);
}
}
}
}

startProcessLocked()方法的流程是，准备好启动应用的参数，调用Process类的start来启动进程，启动进程后AMS给自己发送了一个PROC_START_TIMEOUT_MSG的消息，来防止进程启动超时。如果start()函数返回的结果中usingWrapper的值为true，超时时间设为1200秒。
static final int PROC_START_TIMEOUT_WITH_WRAPPER=1200*1000;
否则超时时间设为10秒。
static final int PROC_START_TIMEOUT=10*1000；
如果时间到了，但是进程还没启动完成，AMS将弹出发生ANR的对话框。

2. 调整进程的位置
AMS的代码中经常调用updateLruProcessLocked()方法来调整某个进程在mLruProcesses列表的位置，mLruProcess是最近使用进程列表（List Of Recent Using的缩写）。每当进程的Activity或者Service发生变化时，意味着进程活动发生了活动，因此，调用这个方法将调整到尽可能最高的位置，同时还要更新关联进程的位置。在mLruProcesses列表中，最近活动的进程总是位于最高位置。同时拥有Activity的进程的位置总是高于只有Service的进程位置。
AMS的成员变量mLruProcessActivityStart和mLruProcessServiceStart分别指向位置最高的、带有Activity进程和没有Activity进程。
updateLruProcessLocked()方法的代码如下：

final void updateLruProcessLocked(ProcessRecord app,boolean activityChange, ProcessRecord client){
//app.activities.size()大于0,表示本进程有活动的Activity。
//app.hasClientActivities的值为true，表示绑定了本进程的Service的
//客户进程有活动的Activity
//treatLikeActivity表示Service启动时带有标记BIND_TREAT_LIKE_ACTVITY
final boolean hasActivity=app.activities.size()>0
||app.hasClientActivities||treatLikeActivity;
final boolean hasService=false;
if(!activityChange&&hasActivity){
//如果ProcessRecord对象已经有了Activity
//再调用本方法，除非是Activity发生变化了才要
return;
}
mLruSeq++;
final long now=SystenClock.uptimeMillis();
app.lastActivityTime=now;//更新lastActivityTime中的时间
if(hasActivity){
//如果进程已经初始化，而且在mLruProcesses列表位置也是最后一项
//这样也没什么可做的，退出
final int N=mLruProcesses.size();
if(N>0&&mLruProcesses.get(N-1)==app){
return ;
}
}else{
//如果进程中没有Activity，而且应景位于mLruProcesses列表的合适位置，退出
if(mLruProcessServiceStart>0&&mLruProcesses.get(mLruProcessServiceStart-1)==app){
return ;
}
}
int lrui=mLruProcess.lastIndexOf(app);
if(app.persistent&&lrui>=0){
return;//带有persistent标志的进程不需要调整，退出
}
if(lrui>=0){
//如果进程已经存在，先从mLruProceses列表中移除，同时调整mLruProcessActivityStart和mLruProcessServiceStart指向的位置
if(lrui<mLruProcessActivityStart){
mLruProcessActivityStart--;
}
if(lrui<mLruProcessServiceStart){
mLruProcessServiceStart--;
}
mLruProcesses.remove(lrui);
}
int nextIndex;
if(hasActivity){
final int N=mLruProcess.size();
if(app.activities.size()==0&&mLruProcessActivityStart<N-1)){
//进程中没有Activity，但是它的Service客户进程中有Activity
mLruProcesses.add(N-1,app);//将进程插入到最后一项
final int uid=app.info.uid;
//如果从倒数第三项开始连续有进程的uid和插入的进程uid相同，把他们的
位置向上移动
for(int i=N-2;i>mLruProcessActivityStart;i--){
processRecord subProc =mPruProcess.get(i);
if(subProc.info.uid==uid){
if(mLruProcesses.get(i).info.uid!=uid){
mLruProcesses.set(i,mLruProcesses.get(i-1));
mLruProcesses.set(i-1,temp);
i--;
}
}else{
break;
}
}

} else{
mLruProcesses.add(app);//进程有Activity，加入到最后一项
}
nextIndex=mLruProcessesServiceStart;//关联进程将要插入的位置
}else if(hasService){
.....//hasService总是为False，这段不会执行
}else{
//如果进程中只有Service,将进程插入到mLruProcessServiceStart指向的位置
int index=mLruProcessServiceStart;
if(client!=null){
......//基本上为null
}
mLruProcess.add(index,app);
nextIndex=index-1; //关联进程插入的位置
mLruProcessActivityStart++;
mLruProcessServiceStart++;
}
//将和本进程的Service关联的客户进程的位置调整到本进程之后
for(int j=app.connections.size()-1;j>=0;j--){
ConnectionRecord cr=app.connections.valueAt(j);
if(cr.binding!=null&&!crserviceDead
&&cr.binding.service!=null&&cr.binding.service.app
!=null &&cr.binding.service.app.lruSeq!=mLruq
&&!cr.binding.service.app.persistent){
nextIndex=updateLruProcessInternalLocked(
cr.binding.service.app,now,nextIntext,
"service connection",cr,app);
}
}
//将和本进程ContentProvider关联的客户进程的位置调整到本进程之后
for(int j=app.conProviders.size()-1;j>=0;j--){
ContentProviderRecord cpr=app.conProviders.get(j).provider;
if(cpr.proc!=null&&cpr.proc.lruSeq!=mLruSeq
&&!cpr.proc.persistent){
nextIndex=updateLruProcessInternalLocked(
cpr.proc,now,nextIntext,
"provider reference",cpr,app);
}
}
}

updateLruProcessLocked()方法中调整进程很重要的一个依据是进程中有没有活动的Activity。除了本身进程存在Activity对象之外，如果和进程中运行的Service相关联的客户进程有Activity，也算进程拥有Activity，这里调整位置的目的是为了将来杀死进程释放内存做准备，如果一个进程关联进程Activity对象存在，那么它的重要性也和真正的和拥有Activity对象的进程相当，如果杀死它，将导致另一个进程出现严重错误，Activity用来显示UI，关系着用户体验，因此尽量不关闭运行Activity组件的进程。
如果一个进程“拥有”Activity，通常会把它插到队列的最高位置，否则，只会把它放到所有没有Activity进程的前面，这个位置正是变量mLruProcessServiceStart所指向的。
调整某个进程的位置之后，还要调整和该进程的关联的位置。进程的关联进程有两种类型：一种是绑定了本进程服务的进程，另一种是连接了本进程的ContentProvider的进程。如果这些进程本身有Activity是不会调整的，需要调整的是那些没有Activity的进程，在updateLruProcessInternalLocked()方法中会执行这种调整，但是，能调整到最高位置也就是mLruProcessServiceStart指向的位置。
updateLruProcessInternalLocked()方法代码如下：

private final int updateLruProcessInternalLocked(ProcessRecord
app,long now,int index,String what,Object obj,ProcessRecord
srcApp){
app.lastActivityTime=now;
if(app.activities.size()>0){
return index;//如果有Activity，不用调整位置。
}
int lrui=mLruProcesses.lastIndexOf(app);
if(lrui<0){
return index;//如果进程不在mLruProcesses中，退出
}
if(lrui>=index){
return index;//如果进程目前的位置高于要调整的位置，退出
}
if(lrui>=mLruProcessActivityStart){
return index; //如果进程目前的位置比有Activity的进程还高，退出
}
//把进程调整到参数index-1的位置
mLruProcesses.remove(this);
if(index>0){
index--;
}
mLruProcesses.add(index,app);
return index;//返回进程的位置

}

这里先解释空进程和cached进程的概念，如果一个进程不包含任何组件，该进程可以认为是空进程，例如，一个进程只包含一个Activity，当这个Activity销毁后变成一个”空”进程。
当Android结束一个进程时，并不会将一个进程立即从系统删除，而是把它标记为cached进程，当再次启动新进程时，优先会使用cached进程吧，这样会加快启动速度。
4. 调整进程的oom_adj值
AMS中调整进程的oom_adj值的方法是updateOomAdjLocked(),代码如下：

final void updateOomAdjLocked() {
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();

if (false) {
RuntimeException e = new RuntimeException();
e.fillInStackTrace();
Slog.i(TAG, "updateOomAdj: top=" + TOP_ACT, e);
}

// Reset state in all uid records.
for (int i=mActiveUids.size()-1; i>=0; i--) {
final UidRecord uidRec = mActiveUids.valueAt(i);
if (false && DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
"Starting update of " + uidRec);
uidRec.reset();
}

mStackSupervisor.rankTaskLayersIfNeeded();

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

final int emptyProcessLimit;
final int cachedProcessLimit;
if (mProcessLimit <= 0) {
emptyProcessLimit = cachedProcessLimit = 0;
} else if (mProcessLimit == 1) {
emptyProcessLimit = 1;
cachedProcessLimit = 0;
} else {
emptyProcessLimit = ProcessList.computeEmptyProcessLimit(mProcessLimit);
cachedProcessLimit = mProcessLimit - emptyProcessLimit;
}

// Let's determine how many processes we have running vs.
// how many slots we have for background processes; we may want
// to put multiple processes in a slot of there are enough of
// them.
int numSlots = (ProcessList.CACHED_APP_MAX_ADJ
- ProcessList.CACHED_APP_MIN_ADJ + 1) / 2;
int numEmptyProcs = N - mNumNonCachedProcs - mNumCachedHiddenProcs;
if (numEmptyProcs > cachedProcessLimit) {
// If there are more empty processes than our limit on cached
// processes, then use the cached process limit for the factor.
// This ensures that the really old empty processes get pushed
// down to the bottom, so if we are running low on memory we will
// have a better chance at keeping around more cached processes
// instead of a gazillion empty processes.
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;

// First update the OOM adjustment for each of the
// application processes based on their current state.
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 (app == null) {
continue;
}
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);
if (DEBUG_OOM_ADJ) Slog.d(TAG,"app.processName = " + app.processName
+ " serviceb = " + app.serviceb + " s = " + s + " sr.lastActivity = "
+ sr.lastActivity + " packageName = " + sr.packageName
+ " processName = " + sr.processName);
if (SystemClock.uptimeMillis() - sr.lastActivity
< mMinBServiceAgingTime) {
if (DEBUG_OOM_ADJ) {
Slog.d(TAG,"Not aged enough!!!");
}
continue;
}
if (serviceLastActivity == 0 && app != TOP_APP) {
serviceLastActivity = sr.lastActivity;
selectedAppRecord = app;
} else if (sr.lastActivity < serviceLastActivity && app != TOP_APP) {
serviceLastActivity = sr.lastActivity;
selectedAppRecord = app;
}
}
}
if (DEBUG_OOM_ADJ && selectedAppRecord != null) Slog.d(TAG,
"Identified app.processName = " + selectedAppRecord.processName
+ " app.pid = " + selectedAppRecord.pid);
if (!app.killedByAm && app.thread != null) {
app.procStateChanged = false;
computeOomAdjLocked(app, ProcessList.UNKNOWN_ADJ, TOP_APP, true, now);

// If we haven't yet assigned the final cached adj
// to the process, do that now.
if (app.curAdj >= ProcessList.UNKNOWN_ADJ) {
switch (app.curProcState) {
case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
// This process is a cached process holding activities...
// assign it the next cached value for that type, and then
// step that cached level.
app.curRawAdj = curCachedAdj;
app.curAdj = app.modifyRawOomAdj(curCachedAdj);
if (DEBUG_LRU && false) Slog.d(TAG_LRU, "Assigning activity LRU #" + i
+ " adj: " + app.curAdj + " (curCachedAdj=" + curCachedAdj
+ ")");
if (curCachedAdj != nextCachedAdj) {
stepCached++;
if (stepCached >= cachedFactor) {
stepCached = 0;
curCachedAdj = nextCachedAdj;
nextCachedAdj += 2;
if (nextCachedAdj > ProcessList.CACHED_APP_MAX_ADJ) {
nextCachedAdj = ProcessList.CACHED_APP_MAX_ADJ;
}
}
}
break;
default:
// For everything else, assign next empty cached process
// level and bump that up. Note that this means that
// long-running services that have dropped down to the
// cached level will be treated as empty (since their process
// state is still as a service), which is what we want.
app.curRawAdj = curEmptyAdj;
app.curAdj = app.modifyRawOomAdj(curEmptyAdj);
if (DEBUG_LRU && false) Slog.d(TAG_LRU, "Assigning empty LRU #" + i
+ " adj: " + app.curAdj + " (curEmptyAdj=" + curEmptyAdj
+ ")");
if (curEmptyAdj != nextEmptyAdj) {
stepEmpty++;
if (stepEmpty >= emptyFactor) {
stepEmpty = 0;
curEmptyAdj = nextEmptyAdj;
nextEmptyAdj += 2;
if (nextEmptyAdj > ProcessList.CACHED_APP_MAX_ADJ) {
nextEmptyAdj = ProcessList.CACHED_APP_MAX_ADJ;
}
}
}
break;
}
}

applyOomAdjLocked(app, true, now, nowElapsed);

// Count the number of process types.
switch (app.curProcState) {
case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY:
case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT:
mNumCachedHiddenProcs++;
numCached++;
if (numCached > cachedProcessLimit) {
app.kill("cached #" + numCached, true);
}
break;
case ActivityManager.PROCESS_STATE_CACHED_EMPTY:
if (numEmpty > ProcessList.TRIM_EMPTY_APPS
&& app.lastActivityTime < oldTime) {
app.kill("empty for "
+ ((oldTime + ProcessList.MAX_EMPTY_TIME - app.lastActivityTime)
/ 1000) + "s", true);
} else {
numEmpty++;
if (numEmpty > emptyProcessLimit) {
app.kill("empty #" + numEmpty, true);
}
}
break;
default:
mNumNonCachedProcs++;
break;
}

if (app.isolated && app.services.size() <= 0) {
// If this is an isolated process, and there are no
// services running in it, then the process is no longer
// needed. We agressively kill these because we can by
// definition not re-use the same process again, and it is
// good to avoid having whatever code was running in them
// left sitting around after no longer needed.
app.kill("isolated not needed", true);
} else {
// Keeping this process, update its uid.
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++;
}
}
}
if ((numBServices > mBServiceAppThreshold) && (true == mAllowLowerMemLevel)
&& (selectedAppRecord != null)) {
ProcessList.setOomAdj(selectedAppRecord.pid, selectedAppRecord.info.uid,
ProcessList.CACHED_APP_MAX_ADJ);
selectedAppRecord.setAdj = selectedAppRecord.curAdj;
if (DEBUG_OOM_ADJ) Slog.d(TAG,"app.processName = " + selectedAppRecord.processName
+ " app.pid = " + selectedAppRecord.pid + " is moved to higher adj");
}

mNumServiceProcs = mNewNumServiceProcs;

// Now determine the memory trimming level of background processes.
// Unfortunately we need to start at the back of the list to do this
// properly. We only do this if the number of background apps we
// are managing to keep around is less than half the maximum we desire;
// if we are keeping a good number around, we'll let them use whatever
// memory they want.
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;
}
// We always allow the memory level to go up (better). We only allow it to go
// down if we are in a state where that is allowed, *and* the total number of processes
// has gone down since last time.
if (DEBUG_OOM_ADJ) Slog.d(TAG_OOM_ADJ, "oom: memFactor=" + memFactor
+ " last=" + mLastMemoryLevel + " allowLow=" + mAllowLowerMemLevel
+ " numProcs=" + mLruProcesses.size() + " last=" + mLastNumProcesses);
if (memFactor > mLastMemoryLevel) {
if (!mAllowLowerMemLevel || mLruProcesses.size() >= mLastNumProcesses) {
memFactor = mLastMemoryLevel;
if (DEBUG_OOM_ADJ) Slog.d(TAG_OOM_ADJ, "Keeping last mem factor!");
}
}
if (memFactor != mLastMemoryLevel) {
EventLogTags.writeAmMemFactor(memFactor, mLastMemoryLevel);
}
mLastMemoryLevel = memFactor;
mLastNumProcesses = mLruProcesses.size();
boolean allChanged = mProcessStats.setMemFactorLocked(memFactor, !isSleepingLocked(), now);
final int trackerMemFactor = mProcessStats.getMemFactorLocked();
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;
int curLevel = ComponentCallbacks2.TRIM_MEMORY_COMPLETE;
for (int i=N-1; i>=0; i--) {
ProcessRecord app = mLruProcesses.get(i);

/* yulong begin add */
/* FEATURE_APP_FREEZE_BACKGROUND */
/* add for app freeze, liuyaxin, 20170519*/
if(ZSFeature.ZEUSIS_FEATURE_APP_FREEZE_BACKGROUND){
if(app.frozenRemoved){
Slog.d(TAG, app.info.packageName + " is frozen and no need to scheduleTrimMemory[updateOomAdjLocked memFactor != ProcessStats.ADJ_MEM_FACTOR_NORMAL]");
continue;
}
}
/* yulong end */

if (allChanged || app.procStateChanged) {
setProcessTrackerStateLocked(app, trackerMemFactor, now);
app.procStateChanged = false;
}
if (app.curProcState >= ActivityManager.PROCESS_STATE_HOME
&& !app.killedByAm) {
if (app.trimMemoryLevel < curLevel && app.thread != null) {
try {
if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ,
"Trimming memory of " + app.processName + " to " + curLevel);
app.thread.scheduleTrimMemory(curLevel);
} catch (RemoteException e) {
}
if (false) {
// For now we won't do this; our memory trimming seems
// to be good enough at this point that destroying
// activities causes more harm than good.
if (curLevel >= ComponentCallbacks2.TRIM_MEMORY_COMPLETE
&& app != mHomeProcess && app != mPreviousProcess) {
// Need to do this on its own message because the stack may not
// be in a consistent state at this point.
// For these apps we will also finish their activities
// to help them free memory.
mStackSupervisor.scheduleDestroyAllActivities(app, "trim");
}
}
}
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) {
try {
if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ,
"Trimming memory of heavy-weight " + app.processName
+ " to " + ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
app.thread.scheduleTrimMemory(
ComponentCallbacks2.TRIM_MEMORY_BACKGROUND);
} catch (RemoteException e) {
}
}
app.trimMemoryLevel = ComponentCallbacks2.TRIM_MEMORY_BACKGROUND;
} else {
if ((app.curProcState >= ActivityManager.PROCESS_STATE_IMPORTANT_BACKGROUND
|| app.systemNoUi) && app.pendingUiClean) {
// If this application is now in the background and it
// had done UI, then give it the special trim level to
// have it free UI resources.
final int level = ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN;
if (app.trimMemoryLevel < level && app.thread != null) {
try {
if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ,
"Trimming memory of bg-ui " + app.processName
+ " to " + level);
app.thread.scheduleTrimMemory(level);
} catch (RemoteException e) {
}
}
app.pendingUiClean = false;
}
if (app.trimMemoryLevel < fgTrimLevel && app.thread != null) {
try {
if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ,
"Trimming memory of fg " + app.processName
+ " to " + fgTrimLevel);
app.thread.scheduleTrimMemory(fgTrimLevel);
} catch (RemoteException e) {
}
}
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);

/* yulong begin add */
/* FEATURE_APP_FREEZE_BACKGROUND */
/* add for app freeze, liuyaxin, 20170519*/
if(ZSFeature.ZEUSIS_FEATURE_APP_FREEZE_BACKGROUND){
if(app.frozenRemoved){
Slog.d(TAG, app.info.packageName + " is frozen and no need to scheduleTrimMemory[updateOomAdjLocked memFactor = ProcessStats.ADJ_MEM_FACTOR_NORMAL]");
continue;
}
}
/* yulong end */

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) {
try {
if (DEBUG_SWITCH || DEBUG_OOM_ADJ) Slog.v(TAG_OOM_ADJ,
"Trimming memory of ui hidden " + app.processName
+ " to " + ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
app.thread.scheduleTrimMemory(
ComponentCallbacks2.TRIM_MEMORY_UI_HIDDEN);
} catch (RemoteException e) {
}
}
app.pendingUiClean = false;
}
app.trimMemoryLevel = 0;
}
}

if (mAlwaysFinishActivities) {
// Need to do this on its own message because the stack may not
// be in a consistent state at this point.
mStackSupervisor.scheduleDestroyAllActivities(null, "always-finish");
}

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

// Update from any uid changes.
for (int i=mActiveUids.size()-1; i>=0; i--) {
final UidRecord uidRec = mActiveUids.valueAt(i);
int uidChange = UidRecord.CHANGE_PROCSTATE;
if (uidRec.setProcState != uidRec.curProcState) {
if (DEBUG_UID_OBSERVERS) Slog.i(TAG_UID_OBSERVERS,
"Changes in " + uidRec + ": proc state from " + uidRec.setProcState
+ " to " + uidRec.curProcState);
if (ActivityManager.isProcStateBackground(uidRec.curProcState)) {
if (!ActivityManager.isProcStateBackground(uidRec.setProcState)) {
uidRec.lastBackgroundTime = nowElapsed;
if (!mHandler.hasMessages(IDLE_UIDS_MSG)) {
// Note: the background settle time is in elapsed realtime, while
// the handler time base is uptime. All this means is that we may
// stop background uids later than we had intended, but that only
// happens because the device was sleeping so we are okay anyway.
mHandler.sendEmptyMessageDelayed(IDLE_UIDS_MSG, BACKGROUND_SETTLE_TIME);
}
}
} else {
if (uidRec.idle) {
uidChange = UidRecord.CHANGE_ACTIVE;
uidRec.idle = false;
}
uidRec.lastBackgroundTime = 0;
}
uidRec.setProcState = uidRec.curProcState;
enqueueUidChangeLocked(uidRec, -1, uidChange);
noteUidProcessState(uidRec.uid, uidRec.curProcState);
}
}

if (mProcessStats.shouldWriteNowLocked(now)) {
mHandler.post(new Runnable() {
@Override public void run() {
synchronized (ActivityManagerService.this) {
mProcessStats.writeStateAsyncLocked();
}
}
});
}

if (DEBUG_OOM_ADJ) {
final long duration = SystemClock.uptimeMillis() - now;
if (false) {
Slog.d(TAG_OOM_ADJ, "Did OOM ADJ in " + duration + "ms",
new RuntimeException("here").fillInStackTrace());
} else {
Slog.d(TAG_OOM_ADJ, "Did OOM ADJ in " + duration + "ms");
}
}
}

updateOomAdjLocked()方法通过调用computeOomAdjLocked()方法来计算进程的oom_adj的值。如果进程的curAdj变量的值仍然大于等于系统预定义的最大oom_adj值（UNKNOW_ADJ），则表明该进程属于“cached”进程或者空进程，updateOomAdjLocked()方法将会为该进程分配oom_adj值。如果用来表示进程状态的变量curProcState的值为PROCESS_STATE_CACHED_ACTIVITY或者PROCESS_STATE_CACHED_ACTIVITY_CLIENT，这说明进程是cached进程，否则为空进程。
updateOomAdjLocked()方法中根据系统定义的cached进程的最大和最小oom_adj的值，先计算出slot的数量，后计算每个slot需要容纳的cached进程的数量cachedFactor和空进程的数量emptyFactor，这样做的目的为了将系统中cached进程和空进程分成不同的级别，每个级别有相同的oom_adj值，级别和级别之间的oom_adj值为2.因此，updateOomAdjLocked()方法区分某个进程是cached进程还是空进程后，会按照从低到高的原则把进程放到某个级别中，如果该几倍进程满了，就进入下一个级别。

Android 进程管理相关推荐

android 进程管理机制,Android的进程管理机制
Linux系统对进程的管理方式是一旦进程活动停止,系统就会结束该进程.Android系统虽基于Linux,但在进程管理上,采取了另外一种机制.当当前进程活动停止时,系统并不会立即结束当前进程,而是会将 ...
手机android进程管理,手机进程管理app_华为手机进程管理_手机自动进程管理软件-多特软件站安卓网...
手机进程管理软件是一款手机进程管理方法app,根据手机进程管理软件你能便捷的控制自己的手机进程,针对有必须的盆友而言非常好. 功能介绍简约实用的android每日任务停止专用工具.你是不是感觉运作的 ...
2018 Android面试心得，已拿到offer，android进程管理器
五.HandlerThread.IntentService理解六.弱引用.软引用区别七.int.Integer有什么区别主要考值传递/引用传递.拆箱/装箱问题八.手写多种生产者/消费者模式 ...
Android进程管理，Android开发者跳槽指南面试必备
雪上加霜本人一名Android程序员,今年29岁了.大厂小厂都呆过,现在在腾讯工作!明明工作顺利,家庭和睦儿女成全,但是总是会感觉到,一股无形的压力,推着我走!作为一名程序员我最怕的不是996,也是 ...
Android系统中的进程管理：进程的优先级
本文是Android进程管理系列文章的第二篇,会讲解进程管理中的优先级管理. 进程管理的第一篇文章:<进程的创建>请跳转至这里. 本文适合Android平台的应用程序开发者,也适合对于An ...
android重复拉起app首页_Android进程管理：Framework层概念
前情回顾 RickAi,公众号:安卓尖端技术研究Android进程管理:从Kernel到LowMemoryKiller 上一篇文章从Native角度讲解了Android进程管理的相关概念,本文将继续从 ...
Android 内存管理 Memory Leak OOM 分析
转载博客:http://blog.csdn.net/vshuang/article/details/39647167 1.Android 进程管理&内存 Android主要应用在嵌入式设备当中 ...
Android内存管理机制
好文摘录原作: https://www.cnblogs.com/nathan909/p/5372981.html 1.基于Linux内存管理 Android系统是基于Linux 2.6内核开发的开源 ...
Android系统中的进程管理：内存的回收
本文是Android系统进程管理的第三篇文章.进程管理的前面两篇文章,请参见这里: Android系统中的进程管理:进程的创建 Android系统中的进程管理:进程的优先级本文适合Android平台 ...

Android 进程管理

Android 进程管理相关推荐

最新文章

热门文章