谁动了我的Activity？

 [[312428]]

前言

不知道大家有没有想过这样一个问题，日常开发中最常用到的通过 startActivity() 唤起一个新的 Activity，所创建的 Activity  对象到底被谁持有引用了?新启动的 Activity 对象在其生命周期中理应是一直被持有引用，不然系统 gc  的时候就会被回收掉，那么其中的引用关系是怎样的呢?

为了搞清楚整个问题，笔者便开始了翻找源码之旅(Android Q)，首先得弄清楚 Activity 实例是如何被创建的。

Activity 对象的创建

Activity 的启动是一个跨进程通信的过程，对客户端而言，Activity 的创建会回调到ActivityThread 中的  handleLaunchActivity() 方法：

复制

@Override public Activity handleLaunchActivity(ActivityClientRecord r,       PendingTransactionActions pendingActions, Intent customIntent){   ···   final Activity a = performLaunchActivity(r, customIntent);   ···   return a; }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

接着在 performLaunchActivity() 方法里找到了 Acitivity 实例的创建：

复制

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {     ···     ContextImpl appContext = createBaseContextForActivity(r);     Activity activity = null;     try {       // 注解1：通过 ClassLoader 以及目标 Activity 的类名来创建新的 Activity 实例         java.lang.ClassLoader cl = appContext.getClassLoader();       activity = mInstrumentation.newActivity(              cl, component.getClassName(), r.intent);       ···     } ··· }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

• 9.

• 10.

• 11.

• 12.

Activity 相关的创建工作交由给了 Instrumentation 类处理：

复制

public Activity newActivity(ClassLoader cl, String className,       Intent intent)       throws InstantiationException, IllegalAccessException,       ClassNotFoundException {   String pkg = intent != null && intent.getComponent() != null               ? intent.getComponent().getPackageName() : null;   return getFactory(pkg).instantiateActivity(cl, className, intent); }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

最终的创建工作由进一步交由工厂类 AppComponentFactory 实现：

复制

public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,       @Nullable Intent intent)       throws InstantiationException, IllegalAccessException, ClassNotFoundException {   return (Activity) cl.loadClass(className).newInstance(); }

• 1.

• 2.

• 3.

• 4.

• 5.

到这里，Activity 对象的创建过程已经很清晰了：通过 ClassLoader 对象以及类名获取到目标 Activity 的 Class 对象，  再调用 Class 对象的 newInstance() 方法创建了实例。

用图形关系表示如下：

Activity 对象的引用关系

在清楚了 Activity 对象的创建过程后，让我们回到一开始的 ActivityThread 的performLaunchActivity()  方法中，接着往下看：

复制

private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) {   ···    ContextImpl appContext = createBaseContextForActivity(r);    Activity activity = null;    ···   try {     Application app = r.packageInfo.makeApplication(false, mInstrumentation);     ···     if (activity != null) {       ···         activity.attach(appContext, this, getInstrumentation(), r.token,           r.ident, app, r.intent, r.activityInfo, title, r.parent,              r.embeddedID, r.lastNonConfigurationInstances, config,           r.referrer, r.voiceInteractor, window, r.configCallback,              r.assistToken);        ···         // 注解2：ActivityClientRecord 对象持有 Activity 实例的引用       r.activity = activity;      }       r.setState(ON_CREATE);      // 注解3：将 ActivityClientRecord 对象添加到 mActivities 集合中     synchronized (mResourcesManager) {        mActivities.put(r.token, r);     }    } ···    return activity; }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

• 9.

• 10.

• 11.

• 12.

• 13.

• 14.

• 15.

• 16.

• 17.

• 18.

• 19.

• 20.

• 21.

• 22.

• 23.

• 24.

• 25.

• 26.

• 27.

• 28.

• 29.

• 30.

在这里，我们似乎找到了想要的答案：

新建的 Activity 对象会被传进来的 ActivityClientRecord 对象所持有，接着该ActivityClientRecord  对象会被添加到一个名为 mActivities 的集合当中所持有。

ActivityClientRecord 是 ActivityThread 的一个静态内部类，用于记录 Activity  相关的信息。其对象的创建过程可以在 LaunchActivityItem 类(Api 28 之后)中找到：

frameworks/base/core/java/android/app/servertransaction/LaunchActivityItem.java:

复制

@Override public void execute(ClientTransactionHandler client, IBinder token,         PendingTransactionActions pendingActions){   Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStart");   ActivityClientRecord r = new ActivityClientRecord(token, mIntent, mIdent, mInfo,       mOverrideConfig, mCompatInfo, mReferrer, mVoiceInteractor, mState, mPersistentState,        mPendingResults, mPendingNewIntents, mIsForward,        mProfilerInfo, client, mAssistToken);    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);    Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

• 9.

• 10.

• 11.

再来看一下这个 mActivities 集合：

frameworks/base/core/java/android/app/ActivityThread.java:

复制

··· final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>(); ···

• 1.

• 2.

• 3.

mActivities 是一个 map 集合，为 ActivityThread 对象的一个成员变量。既然是一个集合，自然也可以在 Activity  销毁方法回调中找到移除集合内元素的操作：

复制

/** Core implementation of activity destroy call. */ ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,      int configChanges, boolean getNonConfigInstance, String reason){   ActivityClientRecord r = mActivities.get(token);   ···   synchronized (mResourcesManager) {     mActivities.remove(token);   }   StrictMode.decrementExpectedActivityCount(activityClass);   return r; }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

• 9.

• 10.

• 11.

图形关系表示如下：

既然 Activity 的对象是间接被 ActivityThread 对象所持有引用，那么该 ActivityThread  对象理应是单例的形式存在，那么该单例 ActivityThread 对象又是如何被创建以及持有的呢?

ActivityThread 对象的创建

一个新的应用进程创建时，会调用 ActivityThread 的静态主方法 main()，在这里，我们找到了答案：

frameworks/base/core/java/android/app/ActivityThread.java:

复制

··· // 注解 4：静态的 ActivityThread 成员变量，用于实现单例 private static volatile ActivityThread sCurrentActivityThread; ···  // 注解 5: ActivityThread 的主方法入口，由 RuntimeInit 调用 public static void main(String[] args) {     ···     Looper.prepareMainLooper();     ···     // 注解 6: 新建一个 ActivityThread 对象     ActivityThread thread = new ActivityThread();     thread.attach(false, startSeq);     ···     Looper.loop();      throw new RuntimeException("Main thread loop unexpectedly exited"); } ···  private void attach(boolean system, long startSeq) {     // 注解 7: ActivityThread 对象由静态成员变量所引用     sCurrentActivityThread = this;     mSystemThread = system;     if (!system) {         android.ddm.DdmHandleAppName.setAppName("<pre-initialized>",                                                 UserHandle.myUserId());         RuntimeInit.setApplicationObject(mAppThread.asBinder());         final IActivityManager mgr = ActivityManager.getService();         try {             mgr.attachApplication(mAppThread, startSeq);         } catch (RemoteException ex) {             throw ex.rethrowFromSystemServer();         }         ···     } ··· }

• 1.

• 2.

• 3.

• 4.

• 5.

• 6.

• 7.

• 8.

• 9.

• 10.

• 11.

• 12.

• 13.

• 14.

• 15.

• 16.

• 17.

• 18.

• 19.

• 20.

• 21.

• 22.

• 23.

• 24.

• 25.

• 26.

• 27.

• 28.

• 29.

• 30.

• 31.

• 32.

• 33.

• 34.

• 35.

• 36.

• 37.

由上面的代码可知，一个新的应用进程创建时，main() 方法里新建一个 ActivityThread 对象赋予给 ActivityThread  类的一个静态成员变量 sCurrentActivityThread，从而形成一个应用进程对应一个 ActivityThread 对象(单例) 的关系。

总结

每一个新启动的 Activity，其对象实例通过 Class 类的 newInstance 方法创建后，被包裹在一个  ActivityClientRecord 对象中然后添加到进程唯一的 ActivityThread 对象的成员变量 mActivitys  里。换言之，Activity 对象的持有和释放都是由 ActivityThread 来管理的。

最后，笔者想额外重申两点：

源码中，Activity 对象会在多个方法都有传递关系，比较复杂，笔者才疏学浅，可能会漏掉一些别的重要的引用关系没有分析，欢迎大家指正。

上文的 framework 源码用的是截稿前最新的 Android Q 版本，不同的 Android  系统版本这部分相关的源码都会有所改动，不能详细一一对比分析，望大家见谅。