誰動了我的Activity？
前言
不知道大家有沒有想過這樣一個問題，日常開發中最常用到的通過 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;
- }
接著在 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);
- ···
- } ···
- }
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);
- }
最終的創建工作由進一步交由工廠類 AppComponentFactory 實現：
- public @NonNull Activity instantiateActivity(@NonNull ClassLoader cl, @NonNull String className,
- @Nullable Intent intent)
- throws InstantiationException, IllegalAccessException, ClassNotFoundException {
- return (Activity) cl.loadClass(className).newInstance();
- }
到這里，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;
- }
在這里，我們似乎找到了想要的答案：
新建的 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);
- }
再來看一下這個 mActivities 集合：
frameworks/base/core/java/android/app/ActivityThread.java:
- ···
- final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>();
- ···
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;
- }
圖形關系表示如下：
既然 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();
- }
- ···
- } ···
- }
由上面的代碼可知，一個新的應用進程創建時，main() 方法里新建一個 ActivityThread 對象賦予給 ActivityThread 類的一個靜態成員變量 sCurrentActivityThread，從而形成一個應用進程對應一個 ActivityThread 對象(單例) 的關系。
總結
每一個新啟動的 Activity，其對象實例通過 Class 類的 newInstance 方法創建后，被包裹在一個 ActivityClientRecord 對象中然后添加到進程唯一的 ActivityThread 對象的成員變量 mActivitys 里。換言之，Activity 對象的持有和釋放都是由 ActivityThread 來管理的。
最后，筆者想額外重申兩點：
源碼中，Activity 對象會在多個方法都有傳遞關系，比較復雜，筆者才疏學淺，可能會漏掉一些別的重要的引用關系沒有分析，歡迎大家指正。
上文的 framework 源碼用的是截稿前最新的 Android Q 版本，不同的 Android 系統版本這部分相關的源碼都會有所改動，不能詳細一一對比分析，望大家見諒。
