文章開始我們首先明白幾個(gè)問題

• appDiedLocked()這個(gè)方法是干什么的？
• 這個(gè)方法從那里調(diào)用過來，最終要達(dá)到什么目的？
• 理解了這個(gè)方法對(duì)于我們有什么好處？

首先我們得明白appDiedLocked()這個(gè)方法是干什么的？這個(gè)方法我從ActivityThread.main()中入手，從這里入手的原因，是因?yàn)檫M(jìn)程創(chuàng)建之后會(huì)從這個(gè)方法開始綁定AMS，在AMS中通過調(diào)用AMS.attachApplicationLocked()這個(gè)方法開始綁定，在這個(gè)方法中會(huì)有對(duì)ApplicationThreadProxy綁定通知，見代碼。

private final boolean attachApplicationLocked(IApplicationThread thread,
        int pid) {
    //綁定死亡通知,此處thread真實(shí)數(shù)據(jù)類型為ApplicationThreadProxy
    AppDeathRecipient adr = new AppDeathRecipient(app, pid, thread);
    thread.asBinder().linkToDeath(adr, 0);
    app.deathRecipient = adr;
}

在這個(gè)過程中，當(dāng)我們binder server掛掉后，會(huì)回調(diào)AppDeathRecipient.binderDied()方法通知client端。
那到這里我們的server端是指應(yīng)用進(jìn)程的ApplicationThread，其中ApplicationThread是在ActivityThread中創(chuàng)建的此時(shí)屬于新建的進(jìn)程（比如新建app的進(jìn)程）。client就是ApplicationThreadProxy對(duì)象，這個(gè)對(duì)象是在AMS中，AMS是在system_server中。所以當(dāng)我們binder server端死亡的時(shí)候（app進(jìn)程死亡）我們system_server進(jìn)程就會(huì)收到通知。做一些處理，我們今天就著重聊聊怎么處理。

appDiedLocked.jpg

1.1 AMS.appDiedLocked()

ActivityManagerService.java

final void appDiedLocked(ProcessRecord app, int pid, IApplicationThread thread,
        boolean fromBinderDied) {
    //當(dāng)進(jìn)程還沒有設(shè)置已被殺的標(biāo)記,則進(jìn)入該分支殺掉相應(yīng)進(jìn)程
    if (!app.killed) {
        //非binder死亡回調(diào),而是上層直接調(diào)用該方法,則進(jìn)入該分支
        if (!fromBinderDied) {
            Process.killProcessQuiet(pid);//關(guān)于這個(gè)方法我們后面會(huì)單獨(dú)寫文章講述
        }
        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) {
            //當(dāng)app不是由am所殺,則往往都是lmk所殺
            if (mHomeProcessName != null && app.processName.equals(mHomeProcessName)) {
                mHomeKilled = true;
                homeRestart = true;
            }
            //既然是由lmk所殺,說明當(dāng)時(shí)內(nèi)存比較緊張,這時(shí)希望能被殺
            mAllowLowerMemLevel = true;
        } else {
            mAllowLowerMemLevel = false;
            doLowMem = false;
        }

        //從ams移除該進(jìn)程以及connections [1.2]
        handleAppDiedLocked(app, false, true);

        //一般為true，則需要更新各個(gè)進(jìn)程的adj
        if (doOomAdj) {
            updateOomAdjLocked();//這個(gè)方法我們后面會(huì)單獨(dú)寫文章總結(jié)
        }

        //當(dāng)進(jìn)程是由lmkd所殺,則進(jìn)入該分支
        if (doLowMem) {
            //只有當(dāng)mLruProcesses中所有進(jìn)程都運(yùn)行在前臺(tái),才報(bào)告內(nèi)存信息
            doLowMemReportIfNeededLocked(app);
        }
        if (mHomeKilled && homeRestart) {
            Intent intent = getHomeIntent();
            //根據(jù)intent解析相應(yīng)的home activity信息
            ActivityInfo aInfo = mStackSupervisor.resolveActivity(intent, null, 0, null, 0);
            //當(dāng)桌面被殺,則立馬再次啟動(dòng)桌面進(jìn)程
            startProcessLocked(aInfo.processName, aInfo.applicationInfo, true, 0,
                    "activity", null, false, false, true);
            homeRestart = false;
        }
    }
}

• 如果應(yīng)用不是被AMS殺的，就是被lmk了，這個(gè)時(shí)候只有的那個(gè)mLruProcesses中如果進(jìn)程都在前臺(tái)，才會(huì)打印內(nèi)存信息。EventLogTags.AM_LOW_MEMORY這個(gè)時(shí)候打印mLruProcesses.size()，我們可以不關(guān)心這個(gè)
• handleAppDiedLocked()這個(gè)方法我們下面講，就是要從AMS中移除這個(gè)進(jìn)程的信息以及一些組件信息。
• updateOomAdjLocked()這個(gè)是用來調(diào)度進(jìn)程優(yōu)先級(jí)的，比較復(fù)雜我們以后單獨(dú)有一篇文章會(huì)研究這個(gè)方法。
• startProcessLocked()當(dāng)桌面被殺的時(shí)候會(huì)立馬啟動(dòng)桌面進(jìn)程

• ==mLruProcesses是一個(gè)通過lru對(duì)進(jìn)程信息的隊(duì)列，首元素是最近最少使用的進(jìn)程==
• ==fromBinderDied是用來判斷是不是通過正常binder死亡回調(diào)調(diào)用過來的方法==

1.2 AMS.handleAppDiedLocked()

ActivityManagerService.java

// restarting = false,  allowRestart = true
private final void handleAppDiedLocked(ProcessRecord app,
        boolean restarting, boolean allowRestart) {
    int pid = app.pid;
    //清理應(yīng)用程序servcie，content providers，BroadcastReceiver[1.3]
    boolean kept = cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1);
    //這里主要看這個(gè)進(jìn)程信息是不是還需要保存，如果不需要保存，并且不需要重啟
    //則會(huì)在lruProcess中去除這個(gè)進(jìn)程信息，并且在ProcessList中移除掉
    if (!kept && !restarting) {
        removeLruProcessLocked(app);
        if (pid > 0) {
            ProcessList.remove(pid);
        }
    }

    //清理activity相關(guān)信息, 當(dāng)應(yīng)用存在可見的activity則返回true [見小節(jié)1.4]
    boolean hasVisibleActivities = mStackSupervisor.handleAppDiedLocked(app);
    app.activities.clear();
    ...
    //當(dāng)死亡的app存在可見的Activity, 則恢復(fù)棧頂?shù)谝粋€(gè)非finish的activity
    if (!restarting && hasVisibleActivities && !mStackSupervisor.resumeTopActivitiesLocked()) {
       //恢復(fù)top activity失敗,則再次確保有可見的activity
       mStackSupervisor.ensureActivitiesVisibleLocked(null, 0);
   }
}

小節(jié)：

• 先通過cleanUpApplicationRecordLocked()清除應(yīng)用里面有關(guān)service, BroadcastReceiver, ContentProvider的記錄相關(guān)。
• 清理activity相關(guān)信息，當(dāng)應(yīng)用存在可見的activity則返回true嘗試進(jìn)行恢復(fù)

==cleanUpApplicationRecordLocked()方法會(huì)打印log：“cleanUpApplicationRecord -- " + app.pid==

那么既然有allowRestart這個(gè)參數(shù)，那么什么時(shí)候傳遞進(jìn)來這個(gè)參數(shù)為true，什么時(shí)候傳遞進(jìn)來為false呢？

1. allowRestart = true

   • attachApplicationLocked
   • startProcessLocked
   • appDiedLocked
   • removeProcessLocked

     killAllBackgroundProcesses 打印reason為：kill all background
     killPackageProcessesLocked 打印reason為AMS調(diào)用forceStopPackageLocked的reason，比較多
     processContentProviderPublishTimedOutLocked 打印reason為：timeout publishing content providers
     

2. 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對(duì)話框
    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();//解除死亡回調(diào)同志
    app.makeInactive(mProcessStats);
    app.waitingToKill = null;
    app.forcingToForeground = null;
    updateProcessForegroundLocked(app, false, false);//將app從前臺(tái)進(jìn)程移除
    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--) {
        //獲取該進(jìn)程已發(fā)表的ContentProvider
        ContentProviderRecord cpr = app.pubProviders.valueAt(i);
        // allowRestart=true，一般地always=false
        final boolean always = app.bad || !allowRestart;
        //ContentProvider服務(wù)端被殺，則client端進(jìn)程也會(huì)被殺
        boolean inLaunching = removeDyingProviderLocked(app, cpr, always);
        if ((inLaunching || always) && cpr.hasConnectionOrHandle()) {
            restart = true; //需要重啟
        }

        cpr.provider = null;
        cpr.proc = null;
    }
    app.pubProviders.clear();

    //處理正在啟動(dòng)并且是有client端正在等待的ContentProvider
    if (cleanupAppInLaunchingProvidersLocked(app, false)) {
        restart = true;
    }

    //取消已連接的ContentProvider的注冊(cè)
    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);
    // 取消注冊(cè)的廣播接收者
    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();

    // 此時(shí)為false，不進(jìn)入該分支
    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) {
        //對(duì)于persistent應(yīng)用，則需要重啟
        // and start a new process for it.
        if (mPersistentStartingProcesses.indexOf(app) < 0) {
            mPersistentStartingProcesses.add(app);
            restart = true;
        }
    }
    //mProcessesOnHold：記錄著試圖在系統(tǒng)ready之前就啟動(dòng)的進(jìn)程。
    //在那時(shí)并不啟動(dòng)這些進(jìn)程，先記錄下來,等系統(tǒng)啟動(dòng)完成則啟動(dòng)這些進(jìn)程。
    mProcessesOnHold.remove(app);
    if (app == mHomeProcess) {
        mHomeProcessName = mHomeProcess.processName;
        mHomeProcess = null;
    }
    if (app == mPreviousProcess) {
        mPreviousProcess = null;
    }

    if (restart && !app.isolated) {
        //仍有組件需要運(yùn)行在該進(jìn)程中，因此重啟該進(jìn)程
        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) {
        //移除該進(jìn)程相關(guān)信息
        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);
    }

    
}

補(bǔ)充說明：

在Android中有一類應(yīng)用屬于persistent應(yīng)用，是一種永久性的應(yīng)用，他們會(huì)在AndroidManifest.xml中將persistent屬性設(shè)置為true。比如：

<application android:name="PhoneApp" 
android:persistent="true" 
android:label="@string/dialerIconLabel" 
android:icon="@drawable/ic_launcher_phone">

在系統(tǒng)啟動(dòng)之時(shí)，AMS的systemReady()會(huì)加載所有persistent為true的應(yīng)用。

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暫停的過程中進(jìn)程已死則無需走暫停流程
    if (mPausingActivity != null && mPausingActivity.app == app) {
        mPausingActivity = null;
    }
    //上次暫停activity,如果運(yùn)行在該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) {
              //當(dāng)該activity可見,則設(shè)置該標(biāo)識(shí)
              if (r.visible) {
                  hasVisibleActivities = true;
              }
              final boolean remove;
              if ((!r.haveState && !r.stateNotNeeded) || r.finishing) {
                  //當(dāng)r沒有狀態(tài) 或者正在結(jié)束,則需要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;

移除下面關(guān)于activity的信息：

• AS.mLRUActivities
• ASS.mStoppingActivities
• ASS.mGoingToSleepActivities
• ASS.mWaitingVisibleActivities
• ASS.mFinishingActivities

總體來說這個(gè)就是清理進(jìn)程相關(guān)的信息，但是有很多疑點(diǎn)，就是里面牽扯到很多組件而且判斷有沒有組件存活，不是進(jìn)程都?xì)⑺懒嗣?，怎么還要判斷組件存活沒？？？暫時(shí)不說了，很晚了，明天繼續(xù)分析。未完待續(xù)...

好了，最后問大神，大神說這里死亡回調(diào)最后做清理工作過程中會(huì)判斷很多東西，比如看是不是存在持久進(jìn)程，是不是activity在前臺(tái)，等等問題，所以不單純是清理工作，而且可能拉起進(jìn)程。