从appDiedLocked()方法谈起

文章开始我们首先明白几个问题

  • 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呢？

  1. allowRestart = true

    • attachApplicationLocked
    • startProcessLocked
    • appDiedLocked
    • removeProcessLocked 
      killAllBackgroundProcesses 打印reason为：kill all background
killPackageProcessesLocked 打印reason为AMS调用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对话框
    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在前台，等等问题，所以不单纯是清理工作，而且可能拉起进程。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 194,670评论 5赞 460
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,928评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,926评论 0赞 320
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,238评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 61,112评论 4赞 356
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,138评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,545评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,232评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,496评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,596评论 2赞 310
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,369评论 1赞 326
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,226评论 3赞 313
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,600评论 3赞 299
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,906评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,185评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,516评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,721评论 2赞 335

推荐阅读更多精彩内容

  • Spring Cloud
    Spring Cloud为开发人员提供了快速构建分布式系统中一些常见模式的工具（例如配置管理，服务发现，断路器，智...
    卡卡罗2017阅读 134,497评论 18赞 139
  • Android - 收藏集
    Android 自定义View的各种姿势1 Activity的显示之ViewRootImpl详解 Activity...
    passiontim阅读 171,073评论 25赞 707
  • Android OS知识点整理
    1:InputChannel提供函数创建底层的Pipe对象 2: 1)客户端需要新建窗口 2)new ViewRo...
    自由人是工程师阅读 5,201评论 0赞 18
  • 兼职
    今天不去了，衣服都脏了，3天下来挣了120，店主都快不干了，由此可见生意的难做，老板的难处，干了一次代驾司机，还是...
    贾和谊阅读 226评论 1赞 2
  • 生活中要除去无下限的低质量勤奋
    深以为然，低质量的勤奋，只是一张画着美丽景色的窗户纸。看似好看，不舍得戳破，陶醉其中，怡然自得。 反省自己，也是一...
    孤岛maurice阅读 161评论 0赞 0