文章開始我們首先明白幾個問題
- appDiedLocked()這個方法是干什么的？
- 這個方法從那里調用過來，最終要達到什么目的？
- 理解了這個方法對于我們有什么好處？
首先我們得明白appDiedLocked()這個方法是干什么的？這個方法我從ActivityThread.main()中入手，從這里入手的原因，是因為進程創建之后會從這個方法開始綁定AMS，在AMS中通過調用AMS.attachApplicationLocked()這個方法開始綁定，在這個方法中會有對ApplicationThreadProxy綁定通知，見代碼。
private final boolean attachApplicationLocked(IApplicationThread thread,
int pid) {
//綁定死亡通知,此處thread真實數據類型為ApplicationThreadProxy
AppDeathRecipient adr = new AppDeathRecipient(app, pid, thread);
thread.asBinder().linkToDeath(adr, 0);
app.deathRecipient = adr;
}
在這個過程中，當我們binder server掛掉后，會回調AppDeathRecipient.binderDied()方法通知client端。
那到這里我們的server端是指應用進程的ApplicationThread，其中ApplicationThread是在ActivityThread中創建的此時屬于新建的進程（比如新建app的進程）。client就是ApplicationThreadProxy對象，這個對象是在AMS中，AMS是在system_server中。所以當我們binder server端死亡的時候（app進程死亡）我們system_server進程就會收到通知。做一些處理，我們今天就著重聊聊怎么處理。
appDiedLocked.jpg
1.1 AMS.appDiedLocked()
ActivityManagerService.java
final void appDiedLocked(ProcessRecord app, int pid, IApplicationThread thread,
boolean fromBinderDied) {
//當進程還沒有設置已被殺的標記,則進入該分支殺掉相應進程
if (!app.killed) {
//非binder死亡回調,而是上層直接調用該方法,則進入該分支
if (!fromBinderDied) {
Process.killProcessQuiet(pid);//關于這個方法我們后面會單獨寫文章講述
}
killProcessGroup(app.info.uid, pid);
app.killed = true;
}
if (app.pid == pid && app.thread != null &&
app.thread.asBinder() == thread.asBinder()) {
//一般為true
boolean doLowMem = app.instrumentationClass == null;
boolean doOomAdj = doLowMem;
boolean homeRestart = false;
if (!app.killedByAm) {
//當app不是由am所殺,則往往都是lmk所殺
if (mHomeProcessName != null && app.processName.equals(mHomeProcessName)) {
mHomeKilled = true;
homeRestart = true;
}
//既然是由lmk所殺,說明當時內存比較緊張,這時希望能被殺
mAllowLowerMemLevel = true;
} else {
mAllowLowerMemLevel = false;
doLowMem = false;
}
//從ams移除該進程以及connections [1.2]
handleAppDiedLocked(app, false, true);
//一般為true，則需要更新各個進程的adj
if (doOomAdj) {
updateOomAdjLocked();//這個方法我們后面會單獨寫文章總結
}
//當進程是由lmkd所殺,則進入該分支
if (doLowMem) {
//只有當mLruProcesses中所有進程都運行在前臺,才報告內存信息
doLowMemReportIfNeededLocked(app);
}
if (mHomeKilled && homeRestart) {
Intent intent = getHomeIntent();
//根據intent解析相應的home activity信息
ActivityInfo aInfo = mStackSupervisor.resolveActivity(intent, null, 0, null, 0);
//當桌面被殺,則立馬再次啟動桌面進程
startProcessLocked(aInfo.processName, aInfo.applicationInfo, true, 0,
"activity", null, false, false, true);
homeRestart = false;
}
}
}
- 如果應用不是被AMS殺的，就是被lmk了，這個時候只有的那個mLruProcesses中如果進程都在前臺，才會打印內存信息。EventLogTags.AM_LOW_MEMORY這個時候打印mLruProcesses.size()，我們可以不關心這個
- handleAppDiedLocked()這個方法我們下面講，就是要從AMS中移除這個進程的信息以及一些組件信息。
- updateOomAdjLocked()這個是用來調度進程優先級的，比較復雜我們以后單獨有一篇文章會研究這個方法。
- startProcessLocked()當桌面被殺的時候會立馬啟動桌面進程
- ==mLruProcesses是一個通過lru對進程信息的隊列，首元素是最近最少使用的進程==
- ==fromBinderDied是用來判斷是不是通過正常binder死亡回調調用過來的方法==
1.2 AMS.handleAppDiedLocked()
ActivityManagerService.java
// restarting = false, allowRestart = true
private final void handleAppDiedLocked(ProcessRecord app,
boolean restarting, boolean allowRestart) {
int pid = app.pid;
//清理應用程序servcie，content providers，BroadcastReceiver[1.3]
boolean kept = cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);
//這里主要看這個進程信息是不是還需要保存，如果不需要保存，并且不需要重啟
//則會在lruProcess中去除這個進程信息，并且在ProcessList中移除掉
if (!kept && !restarting) {
removeLruProcessLocked(app);
if (pid > 0) {
ProcessList.remove(pid);
}
}
//清理activity相關信息, 當應用存在可見的activity則返回true [見小節1.4]
boolean hasVisibleActivities = mStackSupervisor.handleAppDiedLocked(app);
app.activities.clear();
...
//當死亡的app存在可見的Activity, 則恢復棧頂第一個非finish的activity
if (!restarting && hasVisibleActivities && !mStackSupervisor.resumeTopActivitiesLocked()) {
//恢復top activity失敗,則再次確保有可見的activity
mStackSupervisor.ensureActivitiesVisibleLocked(null, 0);
}
}
小節：
- 先通過cleanUpApplicationRecordLocked()清除應用里面有關service, BroadcastReceiver, ContentProvider的記錄相關。
- 清理activity相關信息，當應用存在可見的activity則返回true嘗試進行恢復
==cleanUpApplicationRecordLocked()方法會打印log：“cleanUpApplicationRecord -- " + app.pid==
那么既然有allowRestart這個參數，那么什么時候傳遞進來這個參數為true，什么時候傳遞進來為false呢？
-
allowRestart = true
- attachApplicationLocked
- startProcessLocked
- appDiedLocked
- removeProcessLocked
killAllBackgroundProcesses 打印reason為：kill all background killPackageProcessesLocked 打印reason為AMS調用forceStopPackageLocked的reason，比較多 processContentProviderPublishTimedOutLocked 打印reason為：timeout publishing content providers
-
allowRestart = false
- handleAppCrashLocked
handleAppCrashLocked removeProcessLocked 打印reason為：crash- systemReady
removeProcessLocked 打印的reason為：system update done
1.3 AMS.cleanUpApplicationRecordLocked()
ActivityManagerService.java
private final boolean cleanUpApplicationRecordLocked(ProcessRecord app,
boolean restarting, boolean allowRestart, int index) {
mProcessesToGc.remove(app);
mPendingPssProcesses.remove(app);
------------------------清除crashing的彈框------------------------------
//如果存在，則清除crash/anr/wait對話框
if (app.crashDialog != null && !app.forceCrashReport) {
app.crashDialog.dismiss();
app.crashDialog = null;
}
if (app.anrDialog != null) {
app.anrDialog.dismiss();
app.anrDialog = null;
}
if (app.waitDialog != null) {
app.waitDialog.dismiss();
app.waitDialog = null;
}
app.crashing = false;
app.notResponding = false;
------------------------做一些基本的清理工作------------------------------
app.resetPackageList(mProcessStats);//重置包列表
app.unlinkDeathRecipient();//解除死亡回調同志
app.makeInactive(mProcessStats);
app.waitingToKill = null;
app.forcingToForeground = null;
updateProcessForegroundLocked(app, false, false);//將app從前臺進程移除
app.foregroundActivities = false;
app.hasShownUi = false;
app.treatLikeActivity = false;
app.hasAboveClient = false;
app.hasClientActivities = false;
------------------------清理service------------------------------
mServices.killServicesLocked(app, allowRestart);
boolean restart = false;
------------------------清理ContentProvider------------------------------
...
for (int i = app.pubProviders.size() - 1; i >= 0; i--) {
//獲取該進程已發表的ContentProvider
ContentProviderRecord cpr = app.pubProviders.valueAt(i);
// allowRestart=true，一般地always=false
final boolean always = app.bad || !allowRestart;
//ContentProvider服務端被殺，則client端進程也會被殺
boolean inLaunching = removeDyingProviderLocked(app, cpr, always);
if ((inLaunching || always) && cpr.hasConnectionOrHandle()) {
restart = true; //需要重啟
}
cpr.provider = null;
cpr.proc = null;
}
app.pubProviders.clear();
//處理正在啟動并且是有client端正在等待的ContentProvider
if (cleanupAppInLaunchingProvidersLocked(app, false)) {
restart = true;
}
//取消已連接的ContentProvider的注冊
if (!app.conProviders.isEmpty()) {
for (int i = app.conProviders.size() - 1; i >= 0; i--) {
ContentProviderConnection conn = app.conProviders.get(i);
conn.provider.connections.remove(conn);
stopAssociationLocked(app.uid, app.processName, conn.provider.uid,
conn.provider.name);
}
app.conProviders.clear();
------------------------清理BroadcastReceiver------------------------------
skipCurrentReceiverLocked(app);
// 取消注冊的廣播接收者
for (int i = app.receivers.size() - 1; i >= 0; i--) {
removeReceiverLocked(app.receivers.valueAt(i));
}
------------------------清理process------------------------------
app.receivers.clear();
for (int i = mPendingProcessChanges.size() - 1; i >= 0; i--) {
ProcessChangeItem item = mPendingProcessChanges.get(i);
if (item.pid == app.pid) {
mPendingProcessChanges.remove(i);
mAvailProcessChanges.add(item);
}
}
mUiHandler.obtainMessage(DISPATCH_PROCESS_DIED, app.pid, app.info.uid, null).sendToTarget();
// 此時為false，不進入該分支
if (restarting) {
return false;
}
if (!app.persistent || app.isolated) {
if (!replacingPid) {
removeProcessNameLocked(app.processName, app.uid);
}
if (mHeavyWeightProcess == app) {
mHandler.sendMessage(mHandler.obtainMessage(CANCEL_HEAVY_NOTIFICATION_MSG,
mHeavyWeightProcess.userId, 0));
mHeavyWeightProcess = null;
}
} else if (!app.removed) {
//對于persistent應用，則需要重啟
// and start a new process for it.
if (mPersistentStartingProcesses.indexOf(app) < 0) {
mPersistentStartingProcesses.add(app);
restart = true;
}
}
//mProcessesOnHold：記錄著試圖在系統ready之前就啟動的進程。
//在那時并不啟動這些進程，先記錄下來,等系統啟動完成則啟動這些進程。
mProcessesOnHold.remove(app);
if (app == mHomeProcess) {
mHomeProcessName = mHomeProcess.processName;
mHomeProcess = null;
}
if (app == mPreviousProcess) {
mPreviousProcess = null;
}
if (restart && !app.isolated) {
//仍有組件需要運行在該進程中，因此重啟該進程
if (index < 0) {
ProcessList.remove(app.pid);
}
addProcessNameLocked(app);
startProcessLocked(app, "restart", app.processName);
return true;
} else if (app.pid > 0 && app.pid != MY_PID) {
//移除該進程相關信息
boolean removed;
synchronized (mPidsSelfLocked) {
mPidsSelfLocked.remove(app.pid);
mHandler.removeMessages(PROC_START_TIMEOUT_MSG, app);
}
mBatteryStatsService.noteProcessFinish(app.processName, app.info.uid);
if (app.isolated) {
mBatteryStatsService.removeIsolatedUid(app.uid, app.info.uid);
}
app.setPid(0);
}
}
補充說明：
在Android中有一類應用屬于persistent應用，是一種永久性的應用，他們會在AndroidManifest.xml中將persistent屬性設置為true。比如：
<application android:name="PhoneApp"
android:persistent="true"
android:label="@string/dialerIconLabel"
android:icon="@drawable/ic_launcher_phone">
在系統啟動之時，AMS的systemReady()會加載所有persistent為true的應用。
public void systemReady(final Runnable goingCallback)
{
List apps = AppGlobals.getPackageManager().getPersistentApplications(STOCK_PM_FLAGS);
if (apps != null) {
int N = apps.size();
int i;
for (i=0; i<N; i++) {
ApplicationInfo info = (ApplicationInfo)apps.get(i);
if (info != null && !info.packageName.equals("android")){
addAppLocked(info, false);
}
}
}
}
2.1 ASS.handleAppDiedLocked()
boolean handleAppDiedLocked(ProcessRecord app) {
//Activity暫停的過程中進程已死則無需走暫停流程
if (mPausingActivity != null && mPausingActivity.app == app) {
mPausingActivity = null;
}
//上次暫停activity,如果運行在該app則也清空
if (mLastPausedActivity != null && mLastPausedActivity.app == app) {
mLastPausedActivity = null;
mLastNoHistoryActivity = null;
}
//[見流程3.1]
return removeHistoryRecordsForAppLocked(app);
}
3.1 AS.handleAppDiedLocked
boolean removeHistoryRecordsForAppLocked(ProcessRecord app) {
removeHistoryRecordsForAppLocked(mLRUActivities, app, "mLRUActivities");
removeHistoryRecordsForAppLocked(mStackSupervisor.mStoppingActivities, app,
"mStoppingActivities");
removeHistoryRecordsForAppLocked(mStackSupervisor.mGoingToSleepActivities, app,
"mGoingToSleepActivities");
removeHistoryRecordsForAppLocked(mStackSupervisor.mWaitingVisibleActivities, app,
"mWaitingVisibleActivities");
removeHistoryRecordsForAppLocked(mStackSupervisor.mFinishingActivities, app,
"mFinishingActivities");
boolean hasVisibleActivities = false;
int i = numActivities();
for (int taskNdx = mTaskHistory.size() - 1; taskNdx >= 0; --taskNdx) {
final ArrayList<ActivityRecord> activities = mTaskHistory.get(taskNdx).mActivities;
for (int activityNdx = activities.size() - 1; activityNdx >= 0; --activityNdx) {
final ActivityRecord r = activities.get(activityNdx);
--i;
if (r.app == app) {
//當該activity可見,則設置該標識
if (r.visible) {
hasVisibleActivities = true;
}
final boolean remove;
if ((!r.haveState && !r.stateNotNeeded) || r.finishing) {
//當r沒有狀態 或者正在結束,則需要rmove
remove = true;
} else if (r.launchCount > 2 &&
r.lastLaunchTime > (SystemClock.uptimeMillis()-60000)) {
remove = true;
} else {
remove = false;
}
if (remove) {
if (!r.finishing) {
if (r.state == ActivityState.RESUMED) {
mService.updateUsageStats(r, false);
}
}
} else {
r.app = null;
r.nowVisible = false;
if (!r.haveState) {
r.icicle = null;
}
}
//清理Activity信息
cleanUpActivityLocked(r, true, true);
if (remove) {
//移除Activity
removeActivityFromHistoryLocked(r, "appDied");
}
}
}
}
return hasVisibleActivities;
移除下面關于activity的信息：
- AS.mLRUActivities
- ASS.mStoppingActivities
- ASS.mGoingToSleepActivities
- ASS.mWaitingVisibleActivities
- ASS.mFinishingActivities
總體來說這個就是清理進程相關的信息，但是有很多疑點，就是里面牽扯到很多組件而且判斷有沒有組件存活，不是進程都殺死了么，怎么還要判斷組件存活沒？？？暫時不說了，很晚了，明天繼續分析。未完待續...
好了，最后問大神，大神說這里死亡回調最后做清理工作過程中會判斷很多東西，比如看是不是存在持久進程，是不是activity在前臺，等等問題，所以不單純是清理工作，而且可能拉起進程。
