framework之Activity 生命周期解析（基于Android11源码）

引言

上一篇讲了Activity的创建过程（没看过的小伙伴移步点我前往）。由于篇幅的问题，只分析到OnCreate周期，那这一篇就接着讲余下部分的周期。

在高版本上，activity的周期都是以事务的方式调用，activityThread里面H类的EXECUTE_TRANSACTION 消息正是接收、处理事务的入口，实际最终由TransactionExecutor 处理该事务。（PS：ATMS即ActivityTaskManagerService的简写）

public final class ActivityThread extends ClientTransactionHandler {private final TransactionExecutor mTransactionExecutor = new TransactionExecutor(this);class H extends Handler {      public void handleMessage(Message msg) {case EXECUTE_TRANSACTION:final ClientTransaction transaction = (ClientTransaction) msg.obj;mTransactionExecutor.execute(transaction);if (isSystem()) {transaction.recycle();}.....}}
}

我们来看看整个activity启动过程会走哪些周期，请记住下面的周期和顺序，接下来就会讲讲这些周期是如何调用的

06-20 13:58:04.476 17073 17073 D MainActivity: onCreate:
06-20 13:58:04.481 17073 17073 D MainActivity: onStart:
06-20 13:58:04.483 17073 17073 D MainActivity: onPostCreate:
06-20 13:58:04.483 17073 17073 D MainActivity: onResume:
06-20 13:58:04.494 17073 17073 D MainActivity: onPostResume:
06-20 13:58:08.690 17073 17073 D MainActivity: onPause:
06-20 13:58:10.207 17073 17073 D MainActivity: onStop:
06-20 13:58:10.210 17073 17073 D MainActivity: onDestroy:

1、onCreate

framework之Activity启动流程，里面已经很详细描述了onCreate的调用流程，对应的流程如下

简单来讲，通过LaunchActivityItem调用了ActivityThread的handleLaunchActivity方法。ActivityThread在创建activity实例后，会设置config、window、resource、theme相关资源，在调用activity的attach方法后，会接着调用onCreate方法。

2、onStart

onCreate之后，onStart又是如何调用的呢？这里我们回顾一下TransactionExecutor#execute方法

// 以正确顺序管理事务执行的类。
public class TransactionExecutor {....// 处理服务端传递过来的事务public void execute(ClientTransaction transaction) {....// 该方法中通过遍历 transaction#callbacks 获取到LaunchActivityItem，然后调用onCreate方法executeCallbacks(transaction);executeLifecycleState(transaction);}
}

不知读者发现没有，executeLifecycleState方法还没分析过，很好，续杯 executeLifecycleState！

public class TransactionExecutor {// 将请求的事务转为最终的生命周期private void executeLifecycleState(ClientTransaction transaction) {....final IBinder token = transaction.getActivityToken();// 通过token获取到对应的activityRecordfinal ActivityClientRecord r = mTransactionHandler.getActivityClient(token);// 循环到最终请求状态之前的状态。cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);// 使用适当的参数执行最终转换。lifecycleItem.execute(mTransactionHandler, token, mPendingActions);lifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);}
}

看看cycleToPath方法，这里在拿到lifeCyclePath后就交给了performLifecycleSequence

// 循环到最终请求状态之前的状态。
private void cycleToPath(ActivityClientRecord r, int finish, boolean excludeLastState,ClientTransaction transaction) {final int start = r.getLifecycleState();// 计算活动的主要生命周期状态的路径，并使用从初始状态之后的状态开始的值填充// 比如onStart,onStop周期就是在这里额外加入的final IntArray path = mHelper.getLifecyclePath(start, finish, excludeLastState);performLifecycleSequence(r, path, transaction);
}

我们来到了performLifecycleSequence 方法，看起来是处理全部周期的地方，问题来了，我们怎么知道走到哪个case？

public class TransactionExecutor {private PendingTransactionActions mPendingActions = new PendingTransactionActions();private ClientTransactionHandler mTransactionHandler;...// 通过之前的序列状态过渡为客户端的状态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_CREATE:mTransactionHandler.handleLaunchActivity(r, mPendingActions,null /* customIntent */);break;case ON_START:mTransactionHandler.handleStartActivity(r.token, mPendingActions);break;case ON_RESUME:mTransactionHandler.handleResumeActivity(r.token, false /* finalStateRequest */,r.isForward, "LIFECYCLER_RESUME_ACTIVITY");break;case ON_PAUSE:mTransactionHandler.handlePauseActivity(r.token, false /* finished */,false /* userLeaving */, 0 /* configChanges */, mPendingActions,"LIFECYCLER_PAUSE_ACTIVITY");break;case ON_STOP:mTransactionHandler.handleStopActivity(r.token, 0 /* configChanges */,mPendingActions, false /* finalStateRequest */,"LIFECYCLER_STOP_ACTIVITY");break;case ON_DESTROY:mTransactionHandler.handleDestroyActivity(r.token, false /* finishing */,0 /* configChanges */, false /* getNonConfigInstance */,"performLifecycleSequence. cycling to:" + path.get(size - 1));break;case ON_RESTART:mTransactionHandler.performRestartActivity(r.token, false /* start */);break;....}}}
}public abstract class ActivityLifecycleItem extends ClientTransactionItem {....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;
}

通过debug发现，path的size是1，mValues的第一个值是2，即state为2，显然走到ON_START case，调用mTransactionHandler#handleStartActivity方法。

ClientTransactionHandler其实是一个抽象类，ActivityThread才是具体实现类

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void handleStartActivity(IBinder token, PendingTransactionActions pendingActions) {final ActivityClientRecord r = mActivities.get(token);final Activity activity = r.activity;// Start，即调用start周期activity.performStart("handleStartActivity");// 更新当前的状态r.setState(ON_START);// 恢复实例的状态，即OnRestoreInstanceState周期if (pendingActions.shouldRestoreInstanceState()) {if (r.isPersistable()) {mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state,r.persistentState);} else if (r.state != null) {mInstrumentation.callActivityOnRestoreInstanceState(activity, r.state);}}// 调用 postOnCreate() 周期if (pendingActions.shouldCallOnPostCreate()) {if (r.isPersistable()) {mInstrumentation.callActivityOnPostCreate(activity, r.state,r.persistentState);} else {mInstrumentation.callActivityOnPostCreate(activity, r.state);}}// 将activity设置为可见updateVisibility(r, true /* show */);}// 设置activity的可见状态private void updateVisibility(ActivityClientRecord r, boolean show) {View v = r.activity.mDecor;if (v != null) {if (show) {if (r.newConfig != null) {// 回调onConfigurationChanged方法performConfigurationChangedForActivity(r, r.newConfig);r.newConfig = null;}}....}}
}

从上面可以看到，handleStartActivity 方法主要调用onStart、OnRestoreInstanceState和 postOnCreate 周期。并在最后将activity设置为可见

public class Activity extends ContextThemeWrapper .... {// start 周期的入口final void performStart(String reason) {// 将onStart周期开始事件分发给监听器ActivityLifecycleCallbacksdispatchActivityPreStarted();// 将onStart的逻辑交给mInstrumentationmInstrumentation.callActivityOnStart(this);// 将周期分发给fragmentmFragments.dispatchStart();...// 将onSart周期结束事件分发给监听器ActivityLifecycleCallbacksdispatchActivityPostStarted();}
}

Instrumentation 也只是调用activity的onStart方法，这样做的好处是，可以将周期调用的时机暴露出去。

public class Instrumentation {public void callActivityOnStart(Activity activity) {activity.onStart();}
}

onRestart

至于onRestart周期，这里也贴一下对应的path值

其实就是在onStart的前面插入了onStart 下标值，对应的case调用的是performRestartActivity方法

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void performRestartActivity(IBinder token, boolean start) {ActivityClientRecord r = mActivities.get(token);if (r.stopped) {r.activity.performRestart(start, "performRestartActivity");if (start) {r.setState(ON_START);}}}
}

Activity对应的方法是

public class Activity extends ContextThemeWrapper .... {final void performRestart(boolean start, String reason) {....// 直接调用onRestart周期mInstrumentation.callActivityOnRestart(this);}
}

3、onResume

通过分析onStart周期调用，估计有些同学很快就会想到onResume也是在performLifecycleSequence方法中处理的。因为里面也有ON_RESUME的case。这么想就大错特错了！！！

上面有debug出path的size是1，所以在处理onStart周期后，就会退出循环。那onResume是在哪里调用的呢？

我们回到executeLifecycleState方法，方法最后调用了lifecycleItem.execute。

public class TransactionExecutor {// 将请求的事务转为最终的生命周期private void executeLifecycleState(ClientTransaction transaction) {final ActivityLifecycleItem lifecycleItem = transaction.getLifecycleStateRequest();....final IBinder token = transaction.getActivityToken();// 通过token获取到对应的activityRecordfinal ActivityClientRecord r = mTransactionHandler.getActivityClient(token);// 循环到最终请求状态之前的状态。cycleToPath(r, lifecycleItem.getTargetState(), true /* excludeLastState */, transaction);// 使用适当的参数执行最终转换。lifecycleItem.execute(mTransactionHandler, token, mPendingActions);// 通知ActivityTaskManagerlifecycleItem.postExecute(mTransactionHandler, token, mPendingActions);}
}

而ActivityLifecycleItem是一个抽象类，那就再次debug看看lifecycleItem是哪个具体类吧

lifecycleItem是ResumeActivityItem的实例。

public class ResumeActivityItem extends ActivityLifecycleItem {.....@Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {// 调用了ActivityThread的handleResumeActivityclient.handleResumeActivity(token, true /* finalStateRequest */, mIsForward,"RESUME_ACTIVITY");}@Overridepublic void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {try {// 通知ATMS 当前完成onResumeActivityTaskManager.getService().activityResumed(token);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}}
}

很好，又回到了ActivityThread（这家伙出镜率相当高）

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void handleResumeActivity(IBinder token, boolean finalStateRequest, boolean isForward,String reason) {// 准备调用Resume周期final ActivityClientRecord r = performResumeActivity(token, finalStateRequest, reason);....}
}

handleResumeActivity 方法里面调用了performResumeActivity

public final class ActivityThread extends ClientTransactionHandler {public ActivityClientRecord performResumeActivity(IBinder token, boolean finalStateRequest,String reason) {final ActivityClientRecord r = mActivities.get(token);....try {// 调用activity的performResumer.activity.performResume(r.startsNotResumed, reason);....} catch (Exception e) {....}}
}

最后来到了activity的performResume，调用activity的onResume

public class Activity extends ContextThemeWrapper .... {final void performResume(boolean followedByPause, String reason) {// 将onResume开始事件分发给监听器ActivityLifecycleCallbacksdispatchActivityPreResumed();// 调用Activity的onResume方法mInstrumentation.callActivityOnResume(this);// 将OnResume周期分发给fragmentmFragments.dispatchResume();// 调用onPostResume 周期onPostResume();// 将onResume结束的事件分发给监听器ActivityLifecycleCallbacksdispatchActivityPostResumed();}
}

4、中场小结

经过上面的分析，想必大家对activity周期调用链路有了一定的了解（绕晕了 doge），其中最重要的地方是这里

public class TransactionExecutor {// 是负责activity周期调用的总入口，处理ATMS 的周期事务请求，其中transaction 是ATMS传过来的参数public void execute(ClientTransaction transaction) {final IBinder token = transaction.getActivityToken();if (token != null) {// 处理activity onDestory的情况final Map<IBinder, ClientTransactionItem> activitiesToBeDestroyed =mTransactionHandler.getActivitiesToBeDestroyed();final ClientTransactionItem destroyItem = activitiesToBeDestroyed.get(token);if (destroyItem != null) {if (transaction.getLifecycleStateRequest() == destroyItem) {activitiesToBeDestroyed.remove(token);}if (mTransactionHandler.getActivityClient(token) == null) {return;}}}// 周期回调主要是在这两个方法中executeCallbacks(transaction);executeLifecycleState(transaction);}
}

我们先看execute方法参数ClientTransaction的结构，里面有两个十分重要的成员变量

public class ClientTransaction implements Parcelable, ObjectPoolItem {// 对客户端的单个回调列表。private List<ClientTransactionItem> mActivityCallbacks;// 执行事务后客户端活动应处于的最终生命周期状态。private ActivityLifecycleItem mLifecycleStateRequest;....
}

ClientTransactionItem 又是干啥的？

// 可以调度和执行的客户端回调消息。这些示例可能是活动配置更改、多窗口模式更改、活动结果交付等。
public abstract class ClientTransactionItem implements BaseClientRequest, Parcelable {@LifecycleStatepublic int getPostExecutionState() {return UNDEFINED;}@Overridepublic int describeContents() {return 0;}
}
// 从服务器到客户端的单个请求的基本接口。它们中的每一个都可以在调度之前准备好，并最终执行。
public interface BaseClientRequest extends ObjectPoolItem {// 在调度之前准备客户端请求。这方面的一个示例可能是通知某些值的挂起更新。default void preExecute(ClientTransactionHandler client, IBinder token) {}// 执行请求。void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions);// 执行执行后需要发生的所有操作，例如将结果报告给server 端。default void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {}
}

而ActivityLifecycleItem 是继承ClientTransactionItem。ActivityLifecycleItem就多了一个getTargetState方法

public abstract class ActivityLifecycleItem extends ClientTransactionItem {// 生命周期的下标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;// 活动应达到的最终生命周期状态。@LifecycleStatepublic abstract int getTargetState();
}

我们看看ActivityLifecycleItem的子类，会发现有一些关键的周期实现

结合上面ResumeActivityItem的实现，可以看出ActivityLifecycleItem的子类是负责client端最终周期 调用和周期上报。这里提出到的 最终周期以及 executeLifecycleState 方法也备注了最终周期，是什么意思呢？

我们都知道activity在创建的时候，会一口气走完onCreate、onstart、onResume方法（不知道的看上面周期分析！！！！）。但是在退出的时候就显得有点小气了，先走onPause、过了一会才走onStop、onDestory。这里的onResume、onPause、onDestory就是最终周期，ATMS在发周期事务的时候，就是直接发这些状态(即mLifecycleStateRequest 变量)。至于中间的周期，比如onCreate、onStart就会插在这个事务的过程中调用。

我们回顾一下onCreate的调用：在TransactionExecutor的executeCallbacks方法里面，通过遍历mActivityCallbacks 获取到LaunchActivityItem，由它调用ActivityThread的handleLaunchActivity方法，从而触发onCreate。而onStart则是通过performLifecycleSequence 方法调用ActivityThread的handleStartActivity。

5、onPause

好的，通过上面的小结，大家应该知道onPause周期如何分析了，我们直接看PauseActivityItem的实现

public class PauseActivityItem extends ActivityLifecycleItem {....@Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {// 调用ActivityThread的handlePauseActivityclient.handlePauseActivity(token, mFinished, mUserLeaving, mConfigChanges, pendingActions,"PAUSE_ACTIVITY_ITEM");}@Overridepublic void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {try {//将当前的周期状态告诉ActivityTaskManagerServiceActivityTaskManager.getService().activityPaused(token);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}}
}

来到了ActivityThread的handlePauseActivity方法

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void handlePauseActivity(IBinder token, boolean finished, boolean userLeaving,int configChanges, PendingTransactionActions pendingActions, String reason) {ActivityClientRecord r = mActivities.get(token);if (r != null) {if (userLeaving) {performUserLeavingActivity(r);}r.activity.mConfigChangeFlags |= configChanges;performPauseActivity(r, finished, reason, pendingActions);....}}// 准备调用onPause方法private Bundle performPauseActivity(ActivityClientRecord r, boolean finished, String reason,PendingTransactionActions pendingActions) {....final boolean shouldSaveState = !r.activity.mFinished && r.isPreHoneycomb();if (shouldSaveState) {// 调用onSaveInstanceState周期callActivityOnSaveInstanceState(r);}performPauseActivityIfNeeded(r, reason);.....return shouldSaveState ? r.state : null;}// 调用callActivityOnPause 方法private void performPauseActivityIfNeeded(ActivityClientRecord r, String reason) {....try {r.activity.mCalled = false;mInstrumentation.callActivityOnPause(r.activity);} catch (SuperNotCalledException e) {.....}r.setState(ON_PAUSE);}
}

Instrumentation的callActivityOnPause方法是直接掉用activity的performPause

public class Activity extends ContextThemeWrapper{final void performPause() {mFragments.dispatchPause();mCalled = false;// 调用onPause方法onPause();}
}

6、onStop

onStop周期的调用需要分两种情况：1）Activity没有被销毁，2）Activity被销毁（即调用OnDestory周期）

1）只走onStop周期

通过debug可以看出来，ATMS发过来的是StopActivityItem

对应的path size为0

所以，我们直接看StopActivityItem的实现

public class StopActivityItem extends ActivityLifecycleItem {private static final String TAG = "StopActivityItem";private int mConfigChanges;@Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "activityStop");// 调用ActivityThread的handleStopActivity方法client.handleStopActivity(token, mConfigChanges, pendingActions,true /* finalStateRequest */, "STOP_ACTIVITY_ITEM");Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);}@Overridepublic void postExecute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {// 通知ATMS 当前activity处于onStop状态client.reportStop(pendingActions);}...
}

回到ActivityThread的handleStopActivity方法

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void handleStopActivity(IBinder token, int configChanges,PendingTransactionActions pendingActions, boolean finalStateRequest, String reason) {final ActivityClientRecord r = mActivities.get(token);r.activity.mConfigChangeFlags |= configChanges;final StopInfo stopInfo = new StopInfo();performStopActivityInner(r, stopInfo, true /* saveState */, finalStateRequest,reason);// 将activity设置为不可见updateVisibility(r, false);}private void performStopActivityInner(ActivityClientRecord r, StopInfo info,boolean saveState, boolean finalStateRequest, String reason) {.....callActivityOnStop(r, saveState, reason);}private void callActivityOnStop(ActivityClientRecord r, boolean saveState, String reason) {try {r.activity.performStop(r.mPreserveWindow, reason);} catch (SuperNotCalledException e) {....}}
}

最后到了Activity的performStop方法

public class Activity extends ContextThemeWrapper{final void performStop(boolean preserveWindow, String reason) {mFragments.dispatchStop();// 直接调用activity的onStop方法mInstrumentation.callActivityOnStop(this);}
}

2）走onDestory周期

这种情况与上面的不太一样，在处理完onPause后，ATMS实际发的是OnDestory事务，可以通过debug方式看出来

那onStop周期的事务跑哪去了？在分析onStart周期的时候，有提到 mHelper.getLifecyclePath 这么一个接口，主要的作用就是帮ATMS填充缺省的周期，比如onStart和onStop：

public class TransactionExecutorHelper {// 计算活动的主要生命周期状态的路径，并使用从初始状态之后的状态开始的值填充public IntArray getLifecyclePath(int start, int finish, boolean excludeLastState) {mLifecycleSequence.clear();if (finish >= start) {if (start == ON_START && finish == ON_STOP) {// A case when we from start to stop state soon, we don't need to go// through the resumed, paused state.mLifecycleSequence.add(ON_STOP);} else {// just go therefor (int i = start + 1; i <= finish; i++) {mLifecycleSequence.add(i);}}} ....return mLifecycleSequence;}
}

通过debug我们也可以看出来

   private void performLifecycleSequence(ActivityClientRecord r, IntArray path, ClientTransaction transaction) {switch (state) {case ON_STOP:mTransactionHandler.handleStopActivity(r.token, 0 /* configChanges */,mPendingActions, false /* finalStateRequest */,"LIFECYCLER_STOP_ACTIVITY");break;....}}

接下来的流程就跟上面的一样，这里不再赘述，直接看onDestory周期。

7、onDestory

在分析onStop的时候，通过debug知道ATMS传过来的lifecycleItem是DestroyActivityItem。注意，这里并没有将执行结果通知ATMS。

public class DestroyActivityItem extends ActivityLifecycleItem {@Overridepublic void execute(ClientTransactionHandler client, IBinder token,PendingTransactionActions pendingActions) {client.handleDestroyActivity(token, mFinished, mConfigChanges,false /* getNonConfigInstance */, "DestroyActivityItem");}@Overridepublic int getTargetState() {return ON_DESTROY;}.....
}

来到ActivityThread

public final class ActivityThread extends ClientTransactionHandler {@Overridepublic void handleDestroyActivity(IBinder token, boolean finishing, int configChanges,boolean getNonConfigInstance, String reason) {ActivityClientRecord r = performDestroyActivity(token, finishing,configChanges, getNonConfigInstance, reason);if (r != null) {// 移除 DecorViewcleanUpPendingRemoveWindows(r, finishing);.....// 将DecorView设置为nullr.activity.mDecor = null;....}if (finishing) {try {// 通知ATMS 当前activity已经销毁ActivityTaskManager.getService().activityDestroyed(token);} catch (RemoteException ex) {throw ex.rethrowFromSystemServer();}}}// 活动销毁调用的核心实现。ActivityClientRecord performDestroyActivity(IBinder token, boolean finishing,int configChanges, boolean getNonConfigInstance, String reason) {ActivityClientRecord r = mActivities.get(token);try {r.activity.mCalled = false;// 直接调用activity的performDestroy方法mInstrumentation.callActivityOnDestroy(r.activity);} catch (SuperNotCalledException e) {throw e;}// 将activity对应的token从mActivities中移除synchronized (mResourcesManager) {mActivities.remove(token);}.....}
}

最后来到了activity里面

public class Activity extends ContextThemeWrapper{final void performDestroy() {mDestroyed = true;mWindow.destroy();// 将周期分发给fragmentmFragments.dispatchDestroy();// 调用onDestory周期onDestroy();mFragments.doLoaderDestroy();}
}

至此，activity完整的生命周期就分析完了。

8、完整时序图

献上呕心沥血画出来的activity生命周期时序图！

后记

一顿分析下来，其实核心还是ActivityThread这个类。ATMS通过ClientTransactionItem对象，实现部分的周期调用（OnResume，onPause，onDestory），其他的周期要么通过TransactionExecutorHelper补充调用（比如onCreate，onStart、onStop），要么就是在调用最终周期的时候补充调用（比如onPostCreate，onPostResume）。

ATMS对于周期的调用，就发了三个请求事务item：LaunchActivityItem、PauseActivityItem、DestroyActivityItem。为啥？binder通信虽然很快，但是总会有消耗的。那为啥不去掉PauseActivityItem？这个就涉及到两个Activity之间启动的生命周期顺序了。