源码分析 -- ActivityThread

1. ActivityThread功能

       它管理应用进程的主线程的执行(相当于普通Java程序的main入口函数),并根据AMS的要求负责调度和执行activities、broadcasts和其它操作。

       在Android系统中,在默认情况下,一个应用程序内的各个组件(如Activity、BroadcastReceiver、Service)都会在同一个进程(Process)里执行,且由此进程的【主线程】负责执行。

       在Android系统中,如果有特别指定(通过android:process),也可以让特定组件在不同的进程中运行。无论组件在哪一个进程中运行,默认情况下,他们都由此进程的【主线程】负责执行。

     【主线程】既要处理Activity组件的UI事件,又要处理Service后台服务工作,通常会忙不过来。为了解决此问题,主线程可以创建多个子线程来处理后台服务工作,而本身专心处理UI画面的事件。

     【主线程】的主要责任:

       • 快速处理UI事件。而且只有它才处理UI事件, 其它线程还不能存取UI画面上的对象(如TextView等),此时, 主线程就叫做UI线程。基本上,Android希望UI线程能根据用户的要求做出快速响应,如果UI线程花太多时间处理后台的工作,当UI事件发生时,让用户等待时间超过5秒而未处理,Android系统就会给用户显示ANR提示信息。

         只有UI线程才能执行View派生类的onDraw()函数。

      • 快速处理Broadcast消息。【主线程】除了处理UI事件之外,还要处理Broadcast消息。所以在BroadcastReceiver的onReceive()函数中,不宜占用太长的时间,否则导致【主线程】无法处理其它的Broadcast消息或UI事件。如果占用时间超过10秒, Android系统就会给用户显示ANR提示信息。

      注意事项:

      • 尽量避免让【主线程】执行耗时的操作,让它能快速处理UI事件和Broadcast消息。

      • BroadcastReceiver的子类都是无状态的,即每次启动时,才会创建其对象,然后调用它的onReceive()函数,当执行完onReceive()函数时,就立即删除此对象。由于每次调用其函数时,会重新创建一个新的对象,所以对象里的属性值,是无法让各函数所共享。          

1.1 Thread与SurfaceView

      View组件由UI线程(主线程)所执行。如果需要迅速更新UI画面或UI画图需要较长时间,则需要使用SurfaceView。它可由后台线程(background thread)来执行,而View只能由UI(主)线程执行。SurfaceView内有高效的rendering机制,可以让后台线程快速刷新Surface的内容。

      View ---> UI(主)线程

      SurfaceView ---> 后台线程  

2. Android应用程序主线程stack

如果不单独创建子线程,一个应用包含以下的线程,是系统自动创建的

并不是只有一个main主线程。具体看系统应用的启动流程分析

这些线程运行在不同的进程中,除了main,都是系统进程

应用程序所在的进程中只有main这一个线程


main线程启动的stack如下:

[java]   view plain  copy   在CODE上查看代码片 派生到我的代码片
  1. at android.os.MessageQueue.nativePollOnce(Native Method)      
  2. at android.os.MessageQueue.next(MessageQueue.java:118)    
  3. at android.os.Looper.loop(Looper.java:118)    
  4.   
  5. at android.app.ActivityThread.main(ActivityThread.java:4424)    // Java main入口函数  
  6.   
  7. at java.lang.reflect.Method.invokeNative(Native Method)   
  8. at java.lang.reflect.Method.invoke(Method.java:511)   
  9. at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:784)    
  10. at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:551)   
  11. at dalvik.system.NativeStart.main(Native Method)     
可以看出Java层的入口函数是通过反射调用的 ActivityThread类中的main函数,然后在main函数中进行消息循环。

也就是android的应用进程的入口是ActivityThread,而不是Application.

ActivityThread是主线程,会有个Handler处理消息。

消息处理函数定义如下:

    1. public void handleMessage(Message msg) {  
    2.     switch (msg.what) {  
    3.         //  这里收到消息以后才会反射创建Applicationd 的对象
    4.         case BIND_APPLICATION: // 创建Application对象  
    5.             Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "bindApplication");  
    6.             AppBindData data = (AppBindData)msg.obj;  
    7.             handleBindApplication(data);  
    8.             Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
    9.             break

ActivitiyThread 是应用程序概念空间的重要概念,他建立了应用进程运行的框架,并提供了一个 IActivityThread 接口作为与  Activity Manager Service 的通讯接口 . 通过该接口 AMS 可以将 Activity 的状态变化传递到客户端的 Activity 对象。

3. IApplicationThread关系图


ApplicationThread类是 ActivitiyThread的内部类

private class ApplicationThread extends ApplicationThreadNative {

       // 实现了以下的方法,具体看下面源码分析

        schedulePauseActivity

       scheduleLaunchActivity

}

4. ActivityThread类

4.1 类中关键信息

[java]   view plain  copy   在CODE上查看代码片 派生到我的代码片
  1. /** 
  2.  * This manages the execution of the main thread in an 
  3.  * application process, scheduling and executing activities, 
  4.  * broadcasts, and other operations on it as the activity 
  5.  * manager requests. 
  6.  * 
  7.  * {@hide} 
  8.  */  
  9. public final class ActivityThread {  
  10.   
  11.     static ContextImpl mSystemContext = null;  
  12.   
  13.     static IPackageManager sPackageManager;  
  14.       
  15.     // 创建ApplicationThread实例,以接收AMS指令并执行  
  16.     final ApplicationThread mAppThread = new ApplicationThread();  //定义的内部类
  17.   
  18.     final Looper mLooper = Looper.myLooper();  
  19.   
  20.     final H mH = new H();   // 定义的内部类,Handler子类,用于处理消息
  21.   
  22.     final HashMap<IBinder, ActivityClientRecord> mActivities  
  23.             = new HashMap<IBinder, ActivityClientRecord>();  // 定义的内部类
  24.       
  25.     // List of new activities (via ActivityRecord.nextIdle) that should  
  26.     // be reported when next we idle.  
  27.     ActivityClientRecord mNewActivities = null;  
  28.       
  29.     // Number of activities that are currently visible on-screen.  
  30.     int mNumVisibleActivities = 0;  
  31.       
  32.     final HashMap<IBinder, Service> mServices  
  33.             = new HashMap<IBinder, Service>();  
  34.       
  35.     Application mInitialApplication;  
  36.   
  37.     final ArrayList<Application> mAllApplications  
  38.             = new ArrayList<Application>();  
  39.   
  40.     static final ThreadLocal<ActivityThread> sThreadLocal = new ThreadLocal<ActivityThread>();  
  41.     Instrumentation mInstrumentation;  
  42.   
  43.     static Handler sMainThreadHandler;  // set once in main()  
  44.   
  45.     static final class ActivityClientRecord {  
  46.         IBinder token;  
  47.         int ident;  
  48.         Intent intent;  
  49.         Bundle state;  
  50.         Activity activity;  
  51.         Window window;  
  52.         Activity parent;  
  53.         String embeddedID;  
  54.         Activity.NonConfigurationInstances lastNonConfigurationInstances;  
  55.         boolean paused;  
  56.         boolean stopped;  
  57.         boolean hideForNow;  
  58.         Configuration newConfig;  
  59.         Configuration createdConfig;  
  60.         ActivityClientRecord nextIdle;  
  61.   
  62.         String profileFile;  
  63.         ParcelFileDescriptor profileFd;  
  64.         boolean autoStopProfiler;  
  65.   
  66.         ActivityInfo activityInfo;  
  67.         CompatibilityInfo compatInfo;  
  68.         LoadedApk packageInfo; //包信息,通过调用ActivityThread.getPapckageInfo而获得  
  69.   
  70.         List<ResultInfo> pendingResults;  
  71.         List<Intent> pendingIntents;  
  72.   
  73.         boolean startsNotResumed;  
  74.         boolean isForward;  
  75.         int pendingConfigChanges;  
  76.         boolean onlyLocalRequest;  
  77.   
  78.         View mPendingRemoveWindow;  
  79.         WindowManager mPendingRemoveWindowManager;  
  80.   
  81.         ...  
  82.     }  
  83.     //  ApplicationThread继承自ApplicationThreadNative, 而ApplicationThreadNative又继承自Binder并实现了IApplicationThread接口。IApplicationThread继承自IInterface。这是一个很明显的binder结构,用于Ams通信。IApplicationThread接口定义了对一个程序(linux的进程)操作的接口。ApplicationThread通过binder与Ams通信,并将Ams的调用,通过下面的H类(也就是Hnalder)将消息发送到消息队列,然后进行相应的操作,入activity的start, stop。
  84.     private class ApplicationThread extends ApplicationThreadNative {  
  85.   
  86.         private void updatePendingConfiguration(Configuration config) {  
  87.             synchronized (mPackages) {  
  88.                 if (mPendingConfiguration == null ||  
  89.                         mPendingConfiguration.isOtherSeqNewer(config)) {  
  90.                     mPendingConfiguration = config;  
  91.                 }  
  92.             }  
  93.         }  
  94.         //  给主消息队列发送消息,处理暂停事件
  95.         //  这些方法是在IApplicationThread接口定义的方法,由ApplicationThread这个类实现。应该是由Ams回调的。
  96.         public final void schedulePauseActivity(IBinder token, boolean finished,  
  97.                 boolean userLeaving, int configChanges) {  
  98.             queueOrSendMessage(  
  99.                     finished ? H.PAUSE_ACTIVITY_FINISHING : H.PAUSE_ACTIVITY,  
  100.                     token,  
  101.                     (userLeaving ? 1 : 0),  
  102.                     configChanges);  
  103.         }  
  104.   
  105.         // we use token to identify this activity without having to send the  
  106.         // activity itself back to the activity manager. (matters more with ipc) 
  107.         // startActivity流程中就是调用的这个函数,应该是由AMs调用的。具体的调用时机看AMS的内容
  108.         public final void scheduleLaunchActivity(Intent intent, IBinder token, int ident,  
  109.                 ActivityInfo info, Configuration curConfig, CompatibilityInfo compatInfo,  
  110.                 Bundle state, List<ResultInfo> pendingResults,  
  111.                 List<Intent> pendingNewIntents, boolean notResumed, boolean isForward,  
  112.                 String profileName, ParcelFileDescriptor profileFd, boolean autoStopProfiler) {            
  113.             ActivityClientRecord r = new ActivityClientRecord();  
  114.   
  115.             r.token = token;  
  116.             r.ident = ident;  
  117.             r.intent = intent;  
  118.             r.activityInfo = info;  
  119.             r.compatInfo = compatInfo;  
  120.             r.state = state;  
  121.   
  122.             r.pendingResults = pendingResults;  
  123.             r.pendingIntents = pendingNewIntents;  
  124.   
  125.             r.startsNotResumed = notResumed;  
  126.             r.isForward = isForward;  
  127.   
  128.             r.profileFile = profileName;  
  129.             r.profileFd = profileFd;  
  130.             r.autoStopProfiler = autoStopProfiler;  
  131.   
  132.             updatePendingConfiguration(curConfig);  
  133.             // 往消息队列发送一个消息LAUNCH_ACTIVITY。启动activity.
  134.             queueOrSendMessage(H.LAUNCH_ACTIVITY, r);  
  135.         }  
  136.   
  137.         ...  
  138.     }  
  139.    
  140.     // 处理主线程的消息
  141.     private class H extends Handler {  
  142.   
  143.         public void handleMessage(Message msg) {  
  144.             if (DEBUG_MESSAGES) Slog.v(TAG, ">>> handling: " + codeToString(msg.what));  
  145.             switch (msg.what) {  
  146.                 case LAUNCH_ACTIVITY: {  
  147.                     Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "activityStart");  
  148.                     ActivityClientRecord r = (ActivityClientRecord)msg.obj;  
  149.   
  150.                     r.packageInfo = getPackageInfoNoCheck(  
  151.                             r.activityInfo.applicationInfo, r.compatInfo); 
  152.                     // 对应activity的启动流程,这里面才会反射创建activity的对象和进行初始化,调用onCreate方法
  153.                     handleLaunchActivity(r, null);  
  154.                     Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);  
  155.                 } break;  
  156.                 ...  
  157.             }  
  158.             if (DEBUG_MESSAGES) Slog.v(TAG, "<<< done: " + codeToString(msg.what));  
  159.         }  
  160.          
  161.         ...  
  162.     }  
  163.   
  164.     public static ActivityThread currentActivityThread() {  
  165.         return sThreadLocal.get();  
  166.     }  
  167.   
  168.     // 整个应用程序的入口函数
  169.     public static void main(String[] args) {  
  170.         SamplingProfilerIntegration.start();  
  171.   
  172.         // CloseGuard defaults to true and can be quite spammy.  We  
  173.         // disable it here, but selectively enable it later (via  
  174.         // StrictMode) on debug builds, but using DropBox, not logs.  
  175.         CloseGuard.setEnabled(false);  
  176.   
  177.         Environment.initForCurrentUser();  
  178.   
  179.         // Set the reporter for event logging in libcore  
  180.         EventLogger.setReporter(new EventLoggingReporter());  
  181.   
  182.         Process.setArgV0("<pre-initialized>");  
  183.         
  184.         Looper.prepareMainLooper();  //我们都知道主线程可以使用Handler进行异步通信,因为主线程中已经创建了Looper,而这个Looper就是在这里创建的。如果其他线程需要使用Handler通信,就要自己去创建Looper。
  185.   
  186.         // 创建ActivityThread实例  
  187.         ActivityThread thread = new ActivityThread();  
  188.         thread.attach(false);  
  189.   
  190.         if (sMainThreadHandler == null) {  
  191.             sMainThreadHandler = thread.getHandler();  
  192.         }  
  193.   
  194.         AsyncTask.init();  
  195.   
  196.         if (false) {  
  197.             Looper.myLooper().setMessageLogging(new  
  198.                     LogPrinter(Log.DEBUG, "ActivityThread"));  
  199.         }  
  200.   
  201.         Looper.loop();  // 进入消息循环
  202.   
  203.         throw new RuntimeException("Main thread loop unexpectedly exited");  
  204.     }  
  205. }  

4.2 家族图谱

http://blog.youkuaiyun.com/gaowenboms/article/details/8815163
<think>我们分析ActivityThread的创建过程。ActivityThread是Android应用进程的主线程,负责管理应用的主线程事件循环、处理组件的生命周期回调等。在Android系统中,每个应用进程都有一个ActivityThread实例。 创建ActivityThread的过程主要发生在应用进程启动时,由Zygote进程fork出应用进程后,在应用进程中执行ActivityThread的main()方法开始。下面我们结合源码分析其创建过程: 1. **Zygote fork应用进程**:当需要启动一个新的应用进程时(例如通过startActivity或startService),AMS会向Zygote进程发送一个fork请求。Zygote进程fork出一个新的子进程(即应用进程)[^1]。 2. **应用进程的入口方法**:在fork出的子进程中,会执行`ZygoteInit`的`main`方法中调用的`handleChildProc`方法,该方法会调用`RuntimeInit.applicationInit`,最终通过反射调用`ActivityThread`的`main`方法[^2]。 3. **ActivityThread.main()方法**:这是ActivityThread的入口点,在应用进程的主线程中执行。主要流程包括: - 创建主线程的Looper(通过Looper.prepareMainLooper()) - 创建ActivityThread实例 - 调用ActivityThread.attach()方法,将应用进程绑定到AMS - 启动主线程的消息循环(Looper.loop()) 我们来看一下ActivityThread.main()方法的源码(基于Android 14源码): ```java public final class ActivityThread extends ClientTransactionHandler { // ... 省略其他代码 public static void main(String[] args) { // 初始化主线程Looper Looper.prepareMainLooper(); // 创建ActivityThread实例 ActivityThread thread = new ActivityThread(); // 调用attach方法,绑定到AMS thread.attach(false, startSeq); // 设置主线程Handler if (sMainThreadHandler == null) { sMainThreadHandler = thread.getHandler(); } // 启动消息循环 Looper.loop(); // 如果loop结束,抛出异常 throw new RuntimeException("Main thread loop unexpectedly exited"); } private void attach(boolean system, long startSeq) { // 获取AMS的代理对象 final IActivityManager mgr = ActivityManager.getService(); try { // 通过Binder调用,将应用进程的ApplicationThread对象注册到AMS mgr.attachApplication(mAppThread, startSeq); } catch (RemoteException ex) { throw ex.rethrowFromSystemServer(); } // ... 省略其他代码 } } ``` 4. **ApplicationThread的创建**:在ActivityThread的构造函数中,会创建ApplicationThread对象。ApplicationThread是ActivityThread的内部类,继承自IApplicationThread.Stub,是一个Binder对象,用于AMS与应用进程通信。AMS通过这个Binder对象可以调度应用进程中的组件生命周期。 ```java public final class ActivityThread extends ClientTransactionHandler { final ApplicationThread mAppThread = new ApplicationThread(); private class ApplicationThread extends IApplicationThread.Stub { // 实现一系列scheduleXXX方法,用于接收AMS发送的生命周期调度指令 // 例如:scheduleLaunchActivity, scheduleResumeActivity等 } } ``` 5. **绑定到AMS**:在attach方法中,通过Binder调用(IActivityManager.attachApplication)将ApplicationThread对象传递给AMS。这样AMS就获得了与应用进程通信的桥梁。AMS在收到attachApplication调用后,会进行一系列初始化操作,包括发送BIND_APPLICATION消息给应用进程,启动应用的主Activity等。 6. **处理BIND_APPLICATION消息**:应用进程在收到AMS发来的BIND_APPLICATION消息后,会创建Application对象并调用其onCreate方法。这个过程由ActivityThread的内部类H(一个Handler)处理: ```java public void handleMessage(Message msg) { switch (msg.what) { case BIND_APPLICATION: handleBindApplication((BindApplicationData)msg.obj); break; // ... 其他消息处理 } } ``` 在handleBindApplication方法中,会创建应用的Application对象,并调用其onCreate方法。 7. **启动主Activity**:在应用进程绑定完成后,如果启动的是Activity,AMS会向应用进程发送一个启动Activity的消息(scheduleLaunchActivity),应用进程的ApplicationThread收到消息后,通过Handler(H)转发消息,最终在ActivityThread中执行创建和启动Activity的操作。 总结ActivityThread的创建过程: 1. Zygote fork出应用进程。 2. 应用进程入口执行ActivityThread的main方法。 3. 在main方法中创建主线程Looper和ActivityThread实例。 4. ActivityThread创建ApplicationThread(Binder对象)用于和AMS通信。 5. ActivityThread通过attach方法将ApplicationThread注册到AMS。 6. 应用进程进入消息循环,等待AMS发送消息(如启动Activity、Service等)。 以上是ActivityThread创建过程的核心步骤。下面我们绘制一个简化的时序图来表示这个过程: ``` Zygote进程 -> 应用进程: fork() 应用进程 -> ActivityThread: main() ActivityThread -> Looper: prepareMainLooper() ActivityThread -> new ActivityThread: 创建实例 ActivityThread -> ActivityThread: attach() ActivityThread -> IActivityManager: attachApplication(mAppThread) IActivityManager (AMS) -> ApplicationThread: 绑定成功,发送BIND_APPLICATION等消息 ApplicationThread -> ActivityThread.H: 发送消息(如BIND_APPLICATION) ActivityThread.H -> ActivityThread: 处理消息(如handleBindApplication) ActivityThread -> Application: 创建并调用onCreate() ``` 注意:上述时序图中,IActivityManager是AMS的Binder代理,实际调用发生在AMS进程中。 通过以上分析,我们了解了ActivityThread的创建过程以及它在应用进程中的核心作用。 参考文献: [^1]: ZygoteInit.java中fork子进程的流程 [^2]: ActivityThread的main方法源码 [^3]: ApplicationThread的Binder通信机制 [^4]: ActivityThread内部类H处理消息的机制 相关问题:</think>### Android ActivityThread 创建过程源码分析 ActivityThread 是 Android 应用进程的核心,负责管理应用的主线程事件循环、处理 AMS 的指令、调度四大组件生命周期等。其创建过程涉及系统级进程协作,主要分为以下阶段: --- #### 1. **Zygote 进程 fork 应用进程** 当需要启动新应用时,AMS 通过 socket 向 Zygote 发送 fork 请求: ```java // ZygoteProcess.java public Process.ProcessStartResult start(...) { return zygoteSendArgsAndGetResult(zygoteSocket, argsForZygote); } ``` Zygote 收到请求后 fork 出新进程,新进程继承 Zygote 的预加载资源(类、资源等)[^1]。 --- #### 2. **应用进程初始化** fork 出的子进程执行 `ZygoteInit.handleChildProc()`: ```java // ZygoteInit.java private static void handleChildProc(Arguments parsedArgs, ...) { // 关闭 Zygote 继承的 socket closeServerSocket(); // 初始化运行时环境 RuntimeInit.applicationInit(parsedArgs.targetSdkVersion, ...); } ``` --- #### 3. **ActivityThread.main() 入口** `RuntimeInit.applicationInit()` 最终通过反射调用 `ActivityThread.main()`: ```java // ActivityThread.java public static void main(String[] args) { // 初始化主线程 Looper Looper.prepareMainLooper(); // 创建 ActivityThread 实例 ActivityThread thread = new ActivityThread(); // 绑定到 AMS thread.attach(false, startSeq); // 启动主线程消息循环 Looper.loop(); } ``` --- #### 4. **ActivityThread 构造过程** ##### (1) 关键成员初始化 ```java // ActivityThread.java final ApplicationThread mAppThread = new ApplicationThread(); final H mH = new H(); // 主线程 Handler ``` - **`ApplicationThread`**:继承 `IApplicationThread.Stub` 的 Binder 对象,用于接收 AMS 的跨进程调用(如 `scheduleLaunchActivity`)[^3]。 - **`H`**:继承 Handler 的内部类,处理组件生命周期消息(如 `LAUNCH_ACTIVITY`)。 ##### (2) 创建资源管理器 ```java mResourcesManager = ResourcesManager.getInstance(); ``` --- #### 5. **绑定到 AMS (`attach()`)** ```java // ActivityThread.java private void attach(boolean system, long startSeq) { // 获取 AMS 的 Binder 代理 final IActivityManager mgr = ActivityManager.getService(); // 向 AMS 注册 ApplicationThread mgr.attachApplication(mAppThread, startSeq); } ``` - AMS 收到请求后,通过 `ApplicationThread` 代理向应用进程发送 `BIND_APPLICATION` 消息[^1]。 --- #### 6. **处理 `BIND_APPLICATION` 消息** 主线程 Handler (`H`) 处理消息: ```java // ActivityThread.H public void handleMessage(Message msg) { switch (msg.what) { case BIND_APPLICATION: handleBindApplication((BindApplicationData) msg.obj); break; } } // 创建 Application 并调用 onCreate() private void handleBindApplication(AppBindData data) { // 1. 创建 LoadedApk(应用包信息) final LoadedApk pi = getPackageInfo(...); // 2. 创建 Instrumentation mInstrumentation = new Instrumentation(); // 3. 创建 Application 实例 Application app = pi.makeApplication(false, mInstrumentation); // 4. 调用 Application.onCreate() mInstrumentation.callApplicationOnCreate(app); } ``` --- #### 7. **启动首个 Activity** AMS 通过 `ApplicationThread.scheduleLaunchActivity()` 发送请求: ```java // ApplicationThread.java public final void scheduleLaunchActivity(...) { sendMessage(H.LAUNCH_ACTIVITY, r); } ``` 主线程 Handler 处理 `LAUNCH_ACTIVITY` 消息: ```java // ActivityThread.H case LAUNCH_ACTIVITY: handleLaunchActivity(r, null, "LAUNCH_ACTIVITY"); break; // 创建 Activity 实例 private void handleLaunchActivity(ActivityClientRecord r, ...) { // 1. 通过反射创建 Activity Activity activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); // 2. 调用 Activity.onCreate() mInstrumentation.callActivityOnCreate(activity, r.state); // 3. 调用 Activity.onStart() 和 onResume() handleResumeActivity(r.token, false, "LAUNCH_ACTIVITY"); } ``` 其中 `newActivity()` 通过类加载器创建实例[^4]: ```java // Instrumentation.java public Activity newActivity(ClassLoader cl, String className, Intent intent) { return getFactory(pkg).instantiateActivity(cl, className, intent); } ``` --- ### 关键机制总结 1. **进程隔离** Zygote fork 机制保证每个应用在独立进程中运行。 2. **跨进程通信** AMS 通过 `ApplicationThread` Binder 接口控制应用进程。 3. **主线程消息循环** `ActivityThread` 依赖 `Looper/Handler` 处理生命周期事件。 4. **统一生命周期调度** `Instrumentation` 代理所有组件的生命周期调用(如 `callActivityOnCreate()`)[^2][^4]。 ```mermaid sequenceDiagram participant AMS participant Zygote participant AppProcess participant ActivityThread participant H AMS->>Zygote: fork新进程请求 Zygote->>AppProcess: fork子进程 AppProcess->>ActivityThread: main() ActivityThread->>ActivityThread: 创建实例 ActivityThread->>ActivityThread: attach() ActivityThread->>AMS: 注册ApplicationThread AMS->>ActivityThread: 发送BIND_APPLICATION H->>ActivityThread: handleBindApplication() ActivityThread->>Application: 创建并调用onCreate() AMS->>ActivityThread: scheduleLaunchActivity() H->>ActivityThread: handleLaunchActivity() ActivityThread->>Activity: 创建并启动生命周期 ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值