阅读 569

一个新启动创建的 Activity 对象到底被谁引用了?

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

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

Activity 对象的创建

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

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

@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 类处理:

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

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 实现:

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

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 对象的创建过程后,让我们回到一开始的 ActivityThreadperformLaunchActivity() 方法中,接着往下看:

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 系统版本这部分相关的源码都会有所改动,不能详细一一对比分析,望大家见谅。

本次的分享就到这啦,喜欢的话可以点个赞 👍 或关注呗。如有错误的地方欢迎大家在评论里指出。

关注下面的标签,发现更多相似文章
评论