深入解析Activity生命周期：方法回调时机与AMS交互机制

Activity声明周期可以说是我们开发中最常用的了，从onCreate() -> ... -> onDestroy()，Activity生命周期回调大家肯定都不陌生了，本文尝试从源码角度了解一下各个生命周期方法的执行时机。首先来了解一下AMS、Binder、ActivityThread的概念：

• AMS ：系统服务，运行在system_server进程中，负责管理所有应用进程和Activity的生命周期。它通过Binder与每个应用进程的ActivityThread通信，发送生命周期相关的指令。
• Binder IPC：AMS与ActivityThread之间的通信机制，确保生命周期指令的跨进程传递。
• ActivityThread ：应用进程的主线程，负责处理AMS发送的指令，并执行相应的生命周期方法。ApplicationThread是ActivityThread的一个内部类，ActivityThread 通过ApplicationThread（一个Binder对象）与AMS通信。

在Activity中，onCreate、onStart、onResume 等生命周期方法的回调都是由 AMS（ActivityManagerService） 通过Binder进程间通信（IPC） 来触发的，整个过程涉及应用进程和系统进程（System Server） 之间的交互，核心机制是 Binder IPC。

Activity 生命周期方法的回调时机

当启动一个 Activity 时，系统按照以下流程执行各个生命周期方法：

• 应用请求启动 Activity ：应用调用 startActivity(Intent)，这个方法最终会调用 Instrumentation#execStartActivity，然后通过 ActivityTaskManager 向 AMS 发送启动请求。
• AMS 处理启动请求 ：AMS 运行在 System Server 进程 中，接收到请求后，会进行任务栈管理、启动模式检查、进程调度等操作；AMS 通过 Binder 进程间通信通知 Zygote 进程启动新的应用进程（如果进程未启动）。
• 应用进程创建 Activity：如果 Activity 所属的进程未启动，Zygote 通过 fork() 复制自身创建新的应用进程，并执行 ActivityThread.main()，最终进入 Looper 事件循环；AMS 通过 ApplicationThread（Binder 代理）向应用进程发送 "启动 Activity" 的指令。
• ActivityThread 处理启动 Activity ：消息发送到 Handler后，最终在主线程（UI 线程） 的 H.handleMessage() 方法中处理，最终通过 Instrumentation.newActivity()反射创建Activity实例、调用Activity.attach()绑定 Context、调用Activity的onCreate()、onStart()、onResume()方法，使Activity进入前台。在Activity的生命周期方法执行完成后，ActivityThread会通过Binder IPC通知AMS，告知Activity的状态变化，AMS会根据这些状态变化更新Activity的任务栈和进程优先级。
• 其他生命周期方法的触发 ：当Activity需要暂停、停止或销毁时，AMS会通过类似的流程通知ActivityThread，触发相应的生命周期方法，如onPause()、onStop()、onDestroy()。

以启动Activity为例，来看看它们的交互流程。

1、应用进程 -> AMS（请求启动Activity）

当 Activity 启动时，ContextImpl#startActivity() -> Instrumentation#execStartActivity() 最终调用ActivityTaskManager.getService().startActivity()，然后通过 Binder 向 AMS 发送请求：

//Instrumentation.java
public ActivityResult execStartActivity(
        Context who, IBinder contextThread, IBinder token, Activity target,
        Intent intent, int requestCode, Bundle options) {
        
    IApplicationThread whoThread = (IApplicationThread) contextThread;
    //...省略其他代码...
    try {
        //关键代码
        int result = ActivityTaskManager.getService().startActivity(whoThread,
                who.getOpPackageName(), who.getAttributionTag(), intent,
                intent.resolveTypeIfNeeded(who.getContentResolver()), token,
                target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
        checkStartActivityResult(result, intent);
    } catch (RemoteException e) {
        throw new RuntimeException("Failure from system", e);
    }
    return null;
}

其中 ActivityTaskManager.getService()返回的是IActivityTaskManager的Binder代理对象，它通过 IPC 将 startActivity() 调用发送到 AMS 进程，流程图如下：

这里Instrumentation 作为系统进程 AMS 和 ActivityThread 之间的桥梁，能够协调进程间的生命周期管理和 IPC 通信。此外，Instrumentation还可以用于测试、调试和监控应用生命周期等。

2、AMS -> 应用进程（通知启动 Activity）

如上图所示，AMS中在调用startActivity()之后，经过一系列处理会执行到ActivityTaskSupervisor#realStartActivityLocked()这个关键方法，该方法是 AMS中启动Activity 的核心方法之一，负责完成 Activity 的真正启动，核心代码如下（基于API32）：

//ActivityTaskSupervisor.java
boolean realStartActivityLocked(ActivityRecord r, WindowProcessController proc,
        boolean andResume, boolean checkConfig) throws RemoteException {
    //获取任务栈信息
    final Task task = r.getTask();
    final Task rootTask = task.getRootTask();

    try {
            // ...省略其他代码...
            //1、创建客户端事务，传入的getThread其实就是最终执行事务的ApplicationThread
            final ClientTransaction clientTransaction = ClientTransaction.obtain(
                    proc.getThread(), r.appToken);

            final boolean isTransitionForward = r.isTransitionForward();
            //2、addCallback添加回调，最终会执行到onCreate()
            clientTransaction.addCallback(LaunchActivityItem.obtain(new Intent(r.intent),
                    System.identityHashCode(r), r.info,
                    mergedConfiguration.getGlobalConfiguration(),
                    mergedConfiguration.getOverrideConfiguration(), r.compat,
                    r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
                    proc.getReportedProcState(), r.getSavedState(), r.getPersistentSavedState(),
                    results, newIntents, r.takeOptions(), isTransitionForward,
                    proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
                    r.createFixedRotationAdjustmentsIfNeeded(), r.shareableActivityToken,
                    r.getLaunchedFromBubble()));

            //3、andResume为true时，最终会执行到onResume()
            final ActivityLifecycleItem lifecycleItem;
            if (andResume) {
                lifecycleItem = ResumeActivityItem.obtain(isTransitionForward);
            } else {
                lifecycleItem = PauseActivityItem.obtain();
            }
            clientTransaction.setLifecycleStateRequest(lifecycleItem);

            //4、执行客户端事务
           mService.getLifecycleManager().scheduleTransaction(clientTransaction);

        } catch (RemoteException e) {
            r.launchFailed = true;
            proc.removeActivity(r, true /* keepAssociation */);
            throw e;
        }
    } 
    return true;
}

注意上面标注的1-4处的代码，后面代码讲解中会提到。上述代码4处，mService.getLifecycleManager()是ClientLifecycleManager类型，看下对应的scheduleTransaction()方法：

//ClientLifecycleManager.java
void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    final IApplicationThread client = transaction.getClient();
    transaction.schedule();
}
//transaction通过ClientTransaction.obtain(proc.getThread(), r.appToken)创建，proc.getThread()其实就是ApplicationThread

//ApplicationThread.java
@Override
public void scheduleTransaction(ClientTransaction transaction) throws RemoteException {
    ActivityThread.this.scheduleTransaction(transaction);
}

调用链路是：ClientLifecycleManager#scheduleTransaction -> ApplicationThread#scheduleTransaction -> ActivityThread#scheduleTransaction（到这里为止已经从AMS进程转移到了应用进程），而ActivityThread是没有scheduleTransaction()这个方法的，是在其父类ClientTransactionHandler中实现的：

//ClientTransactionHandler.java
void scheduleTransaction(ClientTransaction transaction) {
    transaction.preExecute(this);
    sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);
}

sendMessage()又回到了子类中，内部主要是向Handler发送一个EXECUTE_TRANSACTION 的消息：

//ActivityThread.java
private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);
public static final int EXECUTE_TRANSACTION = 159;

public void handleMessage(Message msg) {
  switch (msg.what) {
    //...省略其他消息...
    case EXECUTE_TRANSACTION:
         final ClientTransaction transaction = (ClientTransaction) msg.obj;
         mTransactionExecutor.execute(transaction);
         break;
  }
}

在消息处理中，执行到了TransactionExecutor#execute()，点进去看一下：

//TransactionExecutor.java
private TransactionExecutorHelper mHelper = new TransactionExecutorHelper();
private ClientTransactionHandler mTransactionHandler; //ActivityThread父类

public void execute(ClientTransaction transaction) {

    //...忽略其他...
    //执行callback，跟上面2处代码对应
    executeCallbacks(transaction);
    //执行ActivityLifecycleItem，跟上面3处代码对应
    executeLifecycleState(transaction);
}

public void executeCallbacks(ClientTransaction transaction) {
    final List<ClientTransactionItem> callbacks = transaction.getCallbacks();
    final int size = callbacks.size();
    for (int i = 0; i < size; ++i) {
        //从callbacks中取数据
        final ClientTransactionItem item = callbacks.get(i);
        //这里会执行callback
        item.execute(mTransactionHandler, token, mPendingActions);
        item.postExecute(mTransactionHandler, token, mPendingActions);
    }
}

private void executeLifecycleState(ClientTransaction transaction) {
    final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();
    // 执行中间状态
    cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);

    // 执行ActivityLifecycleItem，即ResumeActivityItem
    lifecycleItem.execute(mTransactionHandler, token, mPendingActions);
    lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);
}

private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,
        ClientTransaction transaction) {
    final int start = r.getLifecycleState();
    //这里取create和resume之间的状态，其实就是start状态了
    final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);
    performLifecycleSequence(r, path, transaction);
}

private void performLifecycleSequence(ActivityClientRecord r, IntArray path,
        ClientTransaction transaction) {
    final int size = path.size();
    for (int i = 0, state; i < size; i++) {
        state = path.get(i);
        switch (state) {
            case ON_START:
                mTransactionHandler.handleStartActivity(r, mPendingActions,
                        null /* activityOptions */);
                break;
            //...忽略其他...
        }
    }
}

//ActivityLifecycleItem.java
@Retention(RetentionPolicy.SOURCE)
public @interface LifecycleState{}
public static final int UNDEFINED = -1;
public static final int PRE_ON_CREATE = 0;
public static final int ON_CREATE = 1;
public static final int ON_START = 2;
public static final int ON_RESUME = 3;
public static final int ON_PAUSE = 4;
public static final int ON_STOP = 5;
public static final int ON_DESTROY = 6;
public static final int ON_RESTART = 7;

上面executeCallbacks()方法对应的是上面2处clientTransaction.addCallback(LaunchActivityItem.obtain(...)；而executeLifecycleState对应的是上面3处clientTransaction.setLifecycleStateRequest(ResumeActivityItem.obtain...)，最终执行的是LaunchActivityItem、ResumeActivityItem的execute()方法，，我们分别来看下其中的execute方法：

//LaunchActivityItem.java
@Override
public void execute(ClientTransactionHandler client, IBinder token,
        PendingTransactionActions pendingActions) {
    ActivityClientRecord r = client.getLaunchingActivity(token);
    client.handleLaunchActivity(r, pendingActions, null /* customIntent */);
}

//ResumeActivityItem.java
@Override
public void execute(ClientTransactionHandler client, ActivityClientRecord r,
        PendingTransactionActions pendingActions) {
    client.handleResumeActivity(r, true /* finalStateRequest */, mIsForward,
            "RESUME_ACTIVITY");
}

client其实就是ActivityThread了，所以最终执行到了ActivityThread的handleLaunchActivity()创建Activity并回调onCreate()，执行handleResumeActivity()并回调onResume()。这里还差一个onStart()，这个回调其实是在上面代码中的cycleToPath()方法中（在回调onResume之前），通过查询状态最终在执行到handleStartActivity()，进而回调onStart()的，代码中已有注释，就不在赘述了。

至此，onCreate、onStart、onResume都执行到了，页面也就处于可见状态了。总结一下 AMS -> ActivityThread的调用流程：

→ realStartActivityLocked()  // AMS启动Activity
   → scheduleTransaction()  // 发送ClientTransaction事务
       → handleLaunchActivity() → onCreate()  //ActivityThread启动Activity，进入Activity生命周期
       → handleStartActivity() → onStart() 
       → handleResumeActivity() → onResume()

同理，onPause、onStop、onDestroy也分别是通过handlePauseActivity()、handleStopActivity()、handleDestroyActivity()触发的。

比如一个ActivityA -> ActivityB的过程：

1、打开一个ActivityA: onCreate() → onStart() → onResume() 2、从 ActivityA 启动 ActivityB：

ActivityA: onPause()  ⬅ 失去焦点
ActivityB: onCreate() → onStart() → onResume() ⬅ 进入前台
ActivityA: onStop()  ⬅ 完全不可见

在ActivityB执行完onResume()之后，会通过遍历ActivityStack栈，对已经不在前台的Activity按场景执行相应的onStop()或onDestroy()，在本例中只会执行onStop()。顺便介绍一下 ActivityRecord、TaskRecord、ActivityStack 之间的关系

• ActivityRecord 就是 Activity 在 AMS 进程中的 "影子对象"，AMS 通过 ActivityRecord 维护 Activity 的状态，并控制 Activity 的启动、暂停、销毁等操作。
• TaskRecord 代表一个 任务栈（Task），它包含多个 ActivityRecord。当用户从桌面点击一个 App 图标，系统会创建一个 TaskRecord，然后把 MainActivity 添加到其中，这个 TaskRecord 可能会包含多个 ActivityRecord，比如执行 MainActivity -> DetailActivity -> SettingActivity的打开顺序时，这时候的TaskRecord中如下：

TaskRecord (任务栈)
 ├── ActivityRecord (SettingActivity)
 ├── ActivityRecord (DetailActivity)
 ├── ActivityRecord (MainActivity)

• ActivityStack 是多个TaskRecord的管理者，每个TaskRecord 又管理多个 ActivityRecord，所以最终三者的关系如下：

ActivityStack (管理多个任务栈)
 ├── TaskRecord 1 (任务栈1)
 │     ├── ActivityRecord
 │     ├── ActivityRecord
 │
 ├── TaskRecord 2 (任务栈2)
 │     ├── ActivityRecord
 │     ├── ActivityRecord

总结

1. Activity 的生命周期方法是由 AMS 进程通过 Binder IPC 调用 ApplicationThread 代理对象 触发的。AMS 负责管理任务栈、进程调度，并通过 Binder 进程间通信通知应用进程执行生命周期方法。
2. 应用进程的 ActivityThread 处理 AMS 发送的指令，使用 Handler 切换到 主线程 执行 Activity 的生命周期回调。
3. Binder 机制确保了 应用进程和系统进程解耦，并且 生命周期方法始终在 UI 线程中执行，避免了线程安全问题。

生命周期方法	触发方式	执行时机
onCreate()	由 AMS 通过 ApplicationThread 触发handleLaunchActivity() 调用 onCreate()	Activity 第一次被创建时调用（只调用一次）
onStart()	handleLaunchActivity() 内部调用 onStart()	Activity 即将可见时调用
onResume()	handleResumeActivity()内部调用 onResume()	Activity进入前台，开始与用户交互
onPause()	AMS 在 startActivity() 处理时，通知前一个 Activity 执行 handlePauseActivity()	Activity 失去焦点，进入后台
onStop()	AMS 通过 handleStopActivity() 触发	Activity完全不可见
onDestroy()	通过 handleDestroyActivity() 触发	Activity即将被销毁

推荐阅读

【1】Android | launchMode启动模式详解

【2】Android | IdleHandler的使用分析

【3】Android | 深入理解View.post()获取宽高、Window加载View原理