All process state definitions. (In ActivityManager.java)
259 /** @hide Process does not exist. */ 260 public static final int PROCESS_STATE_NONEXISTENT = -1; 261 262 /** @hide Process is a persistent system process. */ 263 public static final int PROCESS_STATE_PERSISTENT = 0; 264 265 /** @hide Process is a persistent system process and is doing UI. */ 266 public static final int PROCESS_STATE_PERSISTENT_UI = 1; 267 268 /** @hide Process is hosting the current top activities. Note that this covers 269 * all activities that are visible to the user. */ 270 public static final int PROCESS_STATE_TOP = 2; 271 272 /** @hide Process is important to the user, and something they are aware of. */ 273 public static final int PROCESS_STATE_IMPORTANT_FOREGROUND = 3; 274 275 /** @hide Process is important to the user, but not something they are aware of. */ 276 public static final int PROCESS_STATE_IMPORTANT_BACKGROUND = 4; 277 278 /** @hide Process is in the background running a backup/restore operation. */ 279 public static final int PROCESS_STATE_BACKUP = 5; 280 281 /** @hide Process is in the background, but it can't restore its state so we want 282 * to try to avoid killing it. */ 283 public static final int PROCESS_STATE_HEAVY_WEIGHT = 6; 284 285 /** @hide Process is in the background running a service. Unlike oom_adj, this level 286 * is used for both the normal running in background state and the executing 287 * operations state. */ 288 public static final int PROCESS_STATE_SERVICE = 7; 289 290 /** @hide Process is in the background running a receiver. Note that from the 291 * perspective of oom_adj receivers run at a higher foreground level, but for our 292 * prioritization here that is not necessary and putting them below services means 293 * many fewer changes in some process states as they receive broadcasts. */ 294 public static final int PROCESS_STATE_RECEIVER = 8; 295 296 /** @hide Process is in the background but hosts the home activity. */ 297 public static final int PROCESS_STATE_HOME = 9; 298 299 /** @hide Process is in the background but hosts the last shown activity. */ 300 public static final int PROCESS_STATE_LAST_ACTIVITY = 10; 301 302 /** @hide Process is being cached for later use and contains activities. */ 303 public static final int PROCESS_STATE_CACHED_ACTIVITY = 11; 304 305 /** @hide Process is being cached for later use and is a client of another cached 306 * process that contains activities. */ 307 public static final int ROCESS_STATE_CACHED_ACTIVITY_CLIENT = 12; 308 309 /** @hide Process is being cached for later use and is empty. */ 310 public static final int ROCESS_STATE_CACHED_EMPTY = 13;
When it is going to clear the process in PROCESS_STATE_CACHED_ACTIVITY and PROCESS_STATE_CACHED_EMPTY state.
In frameworks/base/services/core/java/com/android/server/am/ActivityManagerService.java
static final int MAX_CACHED_APPS = SystemProperties.getInt("ro.sys.cached_apps_limit", 24); Get the max number of cached apps process.
int mProcessLimit = ProcessList.MAX_CACHED_APPS;19699 final int emptyProcessLimit; 19700 final int cachedProcessLimit; 19701 if (mProcessLimit <= 0) { 19702 emptyProcessLimit = cachedProcessLimit = 0; 19703 } else if (mProcessLimit == 1) { 19704 emptyProcessLimit = 1; 19705 cachedProcessLimit = 0; 19706 } else { 19707 emptyProcessLimit = ProcessList.computeEmptyProcessLimit(mProcessLimit); 19708 cachedProcessLimit = mProcessLimit - emptyProcessLimit; 19709 }
After this, emptyProcessLimit = cachedProcessLimit = mProcessLimit/2
18360 private final int computeOomAdjLocked(ProcessRecord app, int cachedAdj, ProcessRecord TOP_APP, 18361 boolean doingAll, long now) {
19806 // Count the number of process types. 19807 switch (app.curProcState) { 19808 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY: 19809 case ActivityManager.PROCESS_STATE_CACHED_ACTIVITY_CLIENT: 19810 mNumCachedHiddenProcs++; 19811 numCached++; 19812 if (numCached > cachedProcessLimit) { If the number of cache app process exceed mProcessLimit/2, then kill the process in PROCESS_STATE_CACHED_ACTIVITY state 19813 app.kill("cached #" + numCached, true); 19814 } 19815 break; 19816 case ActivityManager.PROCESS_STATE_CACHED_EMPTY: 19817 if (numEmpty > ProcessList.TRIM_EMPTY_APPS 19818 && app.lastActivityTime < oldTime) { if a the number of empty process exceed mProcessLimit/4, and be empty for 30 minutes, kill it. (static final long MAX_EMPTY_TIME = 30*60*1000;) 19819 app.kill("empty for " 19820 + ((oldTime + ProcessList.MAX_EMPTY_TIME - app.lastActivityTime) 19821 / 1000) + "s", true); 19822 } else { 19823 numEmpty++; 19824 if (numEmpty > emptyProcessLimit) { If the number of empty app process exceed mProcessLimit/2, then kill it. 19825 app.kill("empty #" + numEmpty, true); 19826 } 19827 } 19828 break; 19829 default: 19830 mNumNonCachedProcs++; 19831 break; 19832 } 19833
Delay of starting service shen there are many services starting at the moment
320 ComponentName startServiceLocked(IApplicationThread caller, Intent service, 321 String resolvedType, int callingPid, int callingUid, int userId) 322 throws TransactionTooLargeException { 369 370 final ServiceMap smap = getServiceMap(r.userId); 371 boolean addToStarting = false; 372 if (!callerFg && r.app == null && mAm.mStartedUsers.get(r.userId) != null) { 373 ProcessRecord proc = mAm.getProcessRecordLocked(r.processName, r.appInfo.uid, false); 374 if (proc == null || proc.curProcState > ActivityManager.PROCESS_STATE_RECEIVER) { 375 // If this is not coming from a foreground caller, then we may want 376 // to delay the start if there are already other background services 377 // that are starting. This is to avoid process start spam when lots 378 // of applications are all handling things like connectivity broadcasts. 379 // We only do this for cached processes, because otherwise an application 380 // can have assumptions about calling startService() for a service to run 381 // in its own process, and for that process to not be killed before the 382 // service is started. This is especially the case for receivers, which 383 // may start a service in onReceive() to do some additional work and have 384 // initialized some global state as part of that. 385 if (DEBUG_DELAYED_SERVICE) Slog.v(TAG, "Potential start delay of " + r + " in " 386 + proc); 387 if (r.delayed) { 388 // This service is already scheduled for a delayed start; just leave 389 // it still waiting. 390 if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Continuing to delay: " + r); 391 return r.name; 392 } 393 if (smap.mStartingBackground.size() >= mMaxStartingBackground) { SystemProperties.get("ro.config.max_starting_bg", "0") 394 // Something else is starting, delay! 395 Slog.i(TAG, "Delaying start of: " + r); 396 smap.mDelayedStartList.add(r); 397 r.delayed = true; 398 return r.name; 399 } 400 if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Not delaying: " + r); 401 addToStarting = true; 402 } else if (proc.curProcState >= ActivityManager.PROCESS_STATE_SERVICE) { 403 // We slightly loosen when we will enqueue this new service as a background 404 // starting service we are waiting for, to also include processes that are 405 // currently running other services or receivers. 406 addToStarting = true; 407 if (DEBUG_DELAYED_STARTS) Slog.v(TAG, "Not delaying, but counting as bg: " + r); 408 } else if (DEBUG_DELAYED_STARTS) { 420 } 421 } else if (DEBUG_DELAYED_STARTS) { 430 } 431 432 return startServiceInnerLocked(smap, service, r, callerFg, addToStarting); 433 }
How to judge a process is empty or not
18360 private final int computeOomAdjLocked(ProcessRecord app, int cachedAdj, ProcessRecord TOP_APP, 18361 boolean doingAll, long now) { 18371 18372 if (app.thread == null) { Application process not start or die 18373 app.adjSeq = mAdjSeq; 18374 app.curSchedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 18375 app.curProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18376 return (app.curAdj=app.curRawAdj=ProcessList.CACHED_APP_MAX_ADJ); 18377 } 18378 app.adjTypeCode = ActivityManager.RunningAppProcessInfo.REASON_UNKNOWN; 18379 app.adjSource = null; 18380 app.adjTarget = null; 18381 app.empty = false; 18382 app.cached = false; 18383 18384 final int activitiesSize = app.activities.size(); 18417 18418 // Determine the importance of the process, starting with most 18419 // important to least, and assign an appropriate OOM adjustment. 18420 int adj; 18421 int schedGroup; 18422 int procState; 18423 boolean foregroundActivities = false; 18424 BroadcastQueue queue; 18425 if (app == TOP_APP) { current app is on the top of the screen 18426 // The last app on the list is the foreground app. 18427 adj = ProcessList.FOREGROUND_APP_ADJ; 18428 schedGroup = Process.THREAD_GROUP_DEFAULT; 18429 app.adjType = "top-activity"; 18430 foregroundActivities = true; 18431 procState = ActivityManager.PROCESS_STATE_TOP; 18432 } else if (app.instrumentationClass != null) { test application process 18433 // Don't want to kill running instrumentation. 18434 adj = ProcessList.FOREGROUND_APP_ADJ; 18435 schedGroup = Process.THREAD_GROUP_DEFAULT; 18436 app.adjType = "instrumentation"; 18437 procState = ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 18438 } else if ((queue = isReceivingBroadcast(app)) != null) { 18439 // An app that is currently receiving a broadcast also 18440 // counts as being in the foreground for OOM killer purposes. 18441 // It's placed in a sched group based on the nature of the 18442 // broadcast as reflected by which queue it's active in. 18443 adj = ProcessList.FOREGROUND_APP_ADJ; 18444 schedGroup = (queue == mFgBroadcastQueue) 18445 ? Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE; 18446 app.adjType = "broadcast"; 18447 procState = ActivityManager.PROCESS_STATE_RECEIVER; 18448 } else if (app.executingServices.size() > 0) { 18449 // An app that is currently executing a service callback also 18450 // counts as being in the foreground. 18451 adj = ProcessList.FOREGROUND_APP_ADJ; 18452 schedGroup = app.execServicesFg ? 18453 Process.THREAD_GROUP_DEFAULT : Process.THREAD_GROUP_BG_NONINTERACTIVE; 18454 app.adjType = "exec-service"; 18455 procState = ActivityManager.PROCESS_STATE_SERVICE; 18456 //Slog.i(TAG, "EXEC " + (app.execServicesFg ? "FG" : "BG") + ": " + app); 18457 } else { 18458 // As far as we know the process is empty. We may change our mind later. 18459 schedGroup = Process.THREAD_GROUP_BG_NONINTERACTIVE; 18460 // At this point we don't actually know the adjustment. Use the cached adj 18461 // value that the caller wants us to. 18462 adj = cachedAdj; 18463 procState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; current process has not activity, services, receivers. 18464 app.cached = true; 18465 app.empty = true; 18466 app.adjType = "cch-empty"; 18467 } 18468 18469 // Examine all activities if not already foreground. 18470 if (!foregroundActivities && activitiesSize > 0) { 18471 for (int j = 0; j < activitiesSize; j++) { 18682 if ((cr.flags&Context.BIND_WAIVE_PRIORITY) == 0) { 18683 ProcessRecord client = cr.binding.client; 18684 int clientAdj = computeOomAdjLocked(client, cachedAdj, 18685 TOP_APP, doingAll, now); 18686 int clientProcState = client.curProcState; 18687 if (clientProcState >= ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 18688 // If the other app is cached for any reason, for purposes here 18689 // we are going to consider it empty. The specific cached state 18690 // doesn't propagate except under certain conditions. 18691 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18692 } 18767 18768 if ((cr.flags&Context.BIND_NOT_FOREGROUND) == 0) { 18769 if (client.curSchedGroup == Process.THREAD_GROUP_DEFAULT) { 18770 schedGroup = Process.THREAD_GROUP_DEFAULT; 18771 } 18772 if (clientProcState <= ActivityManager.PROCESS_STATE_TOP) { 18773 if (clientProcState == ActivityManager.PROCESS_STATE_TOP) { 18774 // Special handling of clients who are in the top state. 18775 // We *may* want to consider this process to be in the 18776 // top state as well, but only if there is not another 18777 // reason for it to be running. Being on the top is a 18778 // special state, meaning you are specifically running 18779 // for the current top app. If the process is already 18780 // running in the background for some other reason, it 18781 // is more important to continue considering it to be 18782 // in the background state. 18783 mayBeTop = true; 18784 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18785 } else { 18786 // Special handling for above-top states (persistent 18787 // processes). These should not bring the current process 18788 // into the top state, since they are not on top. Instead 18789 // give them the best state after that. 18790 clientProcState = 18791 ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 18792 } 18793 } 18794 } 18841 18842 for (int provi = app.pubProviders.size()-1; 18843 provi >= 0 && (adj > ProcessList.FOREGROUND_APP_ADJ 18844 || schedGroup == Process.THREAD_GROUP_BG_NONINTERACTIVE 18845 || procState > ActivityManager.PROCESS_STATE_TOP); 18846 provi--) { 18847 ContentProviderRecord cpr = app.pubProviders.valueAt(provi); 18861 if (clientProcState >= ActivityManager.PROCESS_STATE_CACHED_ACTIVITY) { 18862 // If the other app is cached for any reason, for purposes here 18863 // we are going to consider it empty. 18864 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18865 } 18882 if (clientProcState <= ActivityManager.PROCESS_STATE_TOP) { 18883 if (clientProcState == ActivityManager.PROCESS_STATE_TOP) { 18884 // Special handling of clients who are in the top state. 18885 // We *may* want to consider this process to be in the 18886 // top state as well, but only if there is not another 18887 // reason for it to be running. Being on the top is a 18888 // special state, meaning you are specifically running 18889 // for the current top app. If the process is already 18890 // running in the background for some other reason, it 18891 // is more important to continue considering it to be 18892 // in the background state. 18893 mayBeTop = true; 18894 clientProcState = ActivityManager.PROCESS_STATE_CACHED_EMPTY; 18895 }