|
|
51CTO旗下网站
|
|
移动端

谁动了我的Activity?

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

作者:JasonWuuu来源:码个蛋|2020-01-10 09:06

 

前言

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

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

Activity 对象的创建

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

  1. @Override 
  2. public Activity handleLaunchActivity(ActivityClientRecord r, 
  3.       PendingTransactionActions pendingActions, Intent customIntent){ 
  4.   ··· 
  5.   final Activity a = performLaunchActivity(r, customIntent); 
  6.   ··· 
  7.   return a; 

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

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

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

  1. public Activity newActivity(ClassLoader cl, String className, 
  2.       Intent intent) 
  3.       throws InstantiationException, IllegalAccessException, 
  4.       ClassNotFoundException { 
  5.   String pkg = intent != null && intent.getComponent() != null 
  6.               ? intent.getComponent().getPackageName() : null
  7.   return getFactory(pkg).instantiateActivity(cl, className, intent); 

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

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

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

用图形关系表示如下:

Activity 对象的引用关系

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

  1. private Activity performLaunchActivity(ActivityClientRecord r, Intent customIntent) { 
  2.   ··· 
  3.    ContextImpl appContext = createBaseContextForActivity(r); 
  4.    Activity activity = null
  5.    ··· 
  6.   try { 
  7.     Application app = r.packageInfo.makeApplication(false, mInstrumentation); 
  8.     ··· 
  9.     if (activity != null) { 
  10.       ··· 
  11.         activity.attach(appContext, this, getInstrumentation(), r.token, 
  12.           r.ident, app, r.intent, r.activityInfo, title, r.parent, 
  13.              r.embeddedID, r.lastNonConfigurationInstances, config, 
  14.           r.referrer, r.voiceInteractor, window, r.configCallback, 
  15.              r.assistToken); 
  16.        ··· 
  17.         // 注解2:ActivityClientRecord 对象持有 Activity 实例的引用 
  18.       r.activity = activity; 
  19.      } 
  20.       r.setState(ON_CREATE); 
  21.  
  22.     // 注解3:将 ActivityClientRecord 对象添加到 mActivities 集合中 
  23.     synchronized (mResourcesManager) { 
  24.        mActivities.put(r.token, r); 
  25.     } 
  26.  
  27.   } ··· 
  28.  
  29.   return activity; 

在这里,我们似乎找到了想要的答案:

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

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

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

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

再来看一下这个 mActivities 集合:

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

  1. ··· 
  2. final ArrayMap<IBinder, ActivityClientRecord> mActivities = new ArrayMap<>(); 
  3. ··· 

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

  1. /** Core implementation of activity destroy call. */ 
  2. ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing, 
  3.      int configChanges, boolean getNonConfigInstance, String reason){ 
  4.   ActivityClientRecord r = mActivities.get(token); 
  5.   ··· 
  6.   synchronized (mResourcesManager) { 
  7.     mActivities.remove(token); 
  8.   } 
  9.   StrictMode.decrementExpectedActivityCount(activityClass); 
  10.   return r; 

图形关系表示如下:

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

ActivityThread 对象的创建

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

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

  1. ··· 
  2. // 注解 4:静态的 ActivityThread 成员变量,用于实现单例 
  3. private static volatile ActivityThread sCurrentActivityThread; 
  4. ··· 
  5.  
  6. // 注解 5: ActivityThread 的主方法入口,由 RuntimeInit 调用 
  7. public static void main(String[] args) { 
  8.     ··· 
  9.     Looper.prepareMainLooper(); 
  10.     ··· 
  11.     // 注解 6: 新建一个 ActivityThread 对象 
  12.     ActivityThread thread = new ActivityThread(); 
  13.     thread.attach(false, startSeq); 
  14.     ··· 
  15.     Looper.loop(); 
  16.  
  17.     throw new RuntimeException("Main thread loop unexpectedly exited"); 
  18. ··· 
  19.  
  20. private void attach(boolean system, long startSeq) { 
  21.     // 注解 7: ActivityThread 对象由静态成员变量所引用 
  22.     sCurrentActivityThread = this; 
  23.     mSystemThread = system; 
  24.     if (!system) { 
  25.         android.ddm.DdmHandleAppName.setAppName("<pre-initialized>"
  26.                                                 UserHandle.myUserId()); 
  27.         RuntimeInit.setApplicationObject(mAppThread.asBinder()); 
  28.         final IActivityManager mgr = ActivityManager.getService(); 
  29.         try { 
  30.             mgr.attachApplication(mAppThread, startSeq); 
  31.         } catch (RemoteException ex) { 
  32.             throw ex.rethrowFromSystemServer(); 
  33.         } 
  34.         ··· 
  35.     } ··· 

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

总结

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

最后,笔者想额外重申两点:

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

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

【编辑推荐】

  1. 通信的未来研究方向,究竟在哪里?
  2. 从操作系统层面理解Linux下的网络IO模型,一篇抵十篇
  3. 鲲鹏生态长虹天宫系统应用示范工程正式落地绵阳
  4. 如何用Python实现TCP的连接与通信?
  5. 超详细的Socket通信原理和实例讲解
【责任编辑:武晓燕 TEL:(010)68476606】

点赞 0
分享:
大家都在看
猜你喜欢

订阅专栏+更多

Python应用场景实战手册

Python应用场景实战手册

Python应用场景实战手册
共3章 | KaliArch

15人订阅学习

一步到位玩儿透Ansible

一步到位玩儿透Ansible

Ansible
共17章 | 骏马金龙1

178人订阅学习

云架构师修炼手册

云架构师修炼手册

云架构师的必备技能
共3章 | Allen在路上

31人订阅学习

读 书 +更多

软件设计师考试考前冲刺预测卷及考点解析

本书依据最新版《软件设计师考试大纲》的考核要求,深入研究了历年软件设计师考试试题的命题风格和试题结构,对考查的知识点进行了提炼,并...

订阅51CTO邮刊

点击这里查看样刊

订阅51CTO邮刊

51CTO服务号

51CTO官微