Android Lifecycle 原理完整剖析：从监听、事件分发到状态驱动

Lifecycle 是 AndroidX 最核心的组件之一。几乎所有架构组件------LiveData、ViewModel、Room、WorkManager------都依赖它。但 Lifecycle 本身的代码其实并不多，核心设计思想非常清晰。

本文从源码层面，把 Lifecycle 的完整工作流程讲清楚。

一、整体架构

Lifecycle 系统由三个角色组成：

markdown 复制代码

LifecycleOwner  →  提供生命周期（Activity / Fragment）
       │
       ▼
LifecycleRegistry  →  管理状态机 + 分发事件
       │
       ▼
LifecycleObserver  →  接收事件回调（你写的代码）

LifecycleOwner ：接口，只有一个 getLifecycle() 方法
LifecycleRegistry ：Lifecycle 的唯一实现类，负责状态管理、Observer 注册、事件分发
LifecycleObserver ：观察者接口，具体有 DefaultLifecycleObserver 和 LifecycleEventObserver

二、核心概念：State 与 Event

State（状态）

java 复制代码

public enum State {
    DESTROYED,   // 已销毁
    INITIALIZED, // 已创建但未开始（构造后、onCreate 之前）
    CREATED,     // onCreate 已调用 / onStop 刚调用
    STARTED,     // onStart 已调用 / onPause 刚调用
    RESUMED      // onResume 已调用（前台可见可交互）
}

Event（事件）

java 复制代码

public enum Event {
    ON_CREATE,
    ON_START,
    ON_RESUME,
    ON_PAUSE,
    ON_STOP,
    ON_DESTROY
}

State 和 Event 的映射关系

Event 是 State 之间迁移的"触发动作"，State 是 Event 执行后的"到达位置"。

正向（Activity 启动过程）：

markdown 复制代码

                   ON_CREATE                 ON_START                 ON_RESUME
INITIALIZED ─────────────────→ CREATED ─────────────────→ STARTED ─────────────────→ RESUMED

反向（Activity 销毁过程）：

markdown 复制代码

                   ON_DESTROY                 ON_STOP                  ON_PAUSE
DESTROYED ←───────────────── CREATED ←───────────────── STARTED ←───────────────── RESUMED

核心映射表：

Event	推进到的 State
ON_CREATE 或 ON_STOP	CREATED
ON_START 或 ON_PAUSE	STARTED
ON_RESUME	RESUMED
ON_DESTROY	DESTROYED

代码实现就是一个简单的 switch：

java 复制代码

// LifecycleRegistry.java --- getStateAfter()
static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREASE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
    }
}

重要规律 ：一个 State 可以由两个不同的 Event 到达。比如 CREATED，既可以从 INITIALIZED 通过 ON_CREATE 到达，也可以从 STARTED 通过 ON_STOP 回退到达。

三、监听机制：Lifecycle 如何感知 Activity 的生命周期

这是理解 Lifecycle 的起点------LifecycleRegistry 是怎么接到 Activity 的生命周期事件的？

3.1 现在的实现：双轨并行

java 复制代码

// ReportFragment.injectIfNeededIn(activity)
@JvmStatic
fun injectIfNeededIn(activity: Activity) {
    if (Build.VERSION.SDK_INT >= 29) {
        // ★ API 29+ → 用 ActivityLifecycleCallbacks 监听
        LifecycleCallbacks.registerIn(activity)
    }
    // ★ API 28 以下 → 用 ReportFragment（无 UI Fragment）代理
    val manager = activity.fragmentManager
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction()
            .add(ReportFragment(), REPORT_FRAGMENT_TAG)
            .commit()
        manager.executePendingTransactions()
    }
}

3.2 API 29+：LifecycleCallbacks

java 复制代码

// LifecycleCallbacks --- 利用 Application.ActivityLifecycleCallbacks
@RequiresApi(29)
class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {

    override fun onActivityPreCreated(activity: Activity, savedInstanceState: Bundle?) {
        // ★ 在 Activity 的 onCreate 之前就注册
        activity.registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
            override fun onActivityPostCreated(activity: Activity, savedInstanceState: Bundle?) {
                dispatch(activity, Lifecycle.Event.ON_CREATE)
            }
            override fun onActivityPostStarted(activity: Activity) {
                dispatch(activity, Lifecycle.Event.ON_START)
            }
            override fun onActivityPostResumed(activity: Activity) {
                dispatch(activity, Lifecycle.Event.ON_RESUME)
            }
            override fun onActivityPrePaused(activity: Activity) {
                dispatch(activity, Lifecycle.Event.ON_PAUSE)
            }
            override fun onActivityPreStopped(activity: Activity) {
                dispatch(activity, Lifecycle.Event.ON_STOP)
            }
            override fun onActivityPreDestroyed(activity: Activity) {
                dispatch(activity, Lifecycle.Event.ON_DESTROY)
            }
        })
    }

    private fun dispatch(activity: Activity, event: Lifecycle.Event) {
        if (activity is LifecycleOwner) {
            // ★ 获取 Activity 的 LifecycleRegistry，传入事件
            (activity.lifecycle as LifecycleRegistry).handleLifecycleEvent(event)
        }
    }
}

注意这里的 Post 和 Pre 的区别：

Activity 生命周期	回调时机	Lifecycle 事件
onCreate 完成后	`onActivityPostCreated`	ON_CREATE
onStart 完成后	`onActivityPostStarted`	ON_START
onResume 完成后	`onActivityPostResumed`	ON_RESUME
onPause 之前	`onActivityPrePaused`	ON_PAUSE
onStop 之前	`onActivityPreStopped`	ON_STOP
onDestroy 之前	`onActivityPreDestroyed`	ON_DESTROY

正向事件在生命周期方法之后分发，反向事件在之前分发。这样 Observer 回调时，Activity 的状态已经是最新的。

3.3 API 28 以下：ReportFragment

java 复制代码

// ReportFragment.java
class ReportFragment : Fragment() {

    override fun onStart() {
        super.onStart()
        dispatch(Lifecycle.Event.ON_START)
    }

    override fun onStop() {
        super.onStop()
        dispatch(Lifecycle.Event.ON_STOP)
    }

    // ... 其他生命周期方法同理

    private fun dispatch(event: Lifecycle.Event) {
        if (activity is LifecycleOwner) {
            (activity.lifecycle as LifecycleRegistry).handleLifecycleEvent(event)
        }
    }
}

原理：ReportFragment 是一个无 UI 的 Fragment，在 Activity 创建时被添加到 FragmentManager。FragmentManager 会跟随 Activity 自动回调 ReportFragment 的生命周期方法。

scss 复制代码

Activity.onCreate()
  → ReportFragment 被添加到 FragmentManager
  → ReportFragment 收到 onStart → dispatch(ON_START)
  → ReportFragment 收到 onStop  → dispatch(ON_STOP)

两种方式的最终目的相同：调 LifecycleRegistry.handleLifecycleEvent(event)，把生命周期事件传给状态机。

四、事件处理：handleLifecycleEvent → moveToState → sync

4.1 handleLifecycleEvent()

java 复制代码

// LifecycleRegistry.java
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    // ★ 根据 Event 算出目标 State
    State next = getStateAfter(event);
    // ★ 移动到目标 State
    moveToState(next);
}

就两行。把 Event 转换成 State，然后移动过去。

4.2 moveToState()

java 复制代码

// LifecycleRegistry.java
private void moveToState(State next) {
    // ★ 如果状态没变 → 什么都不做（防止重复分发）
    if (mState == next) {
        return;
    }

    // 更新全局状态
    mState = next;

    // ★ 如果没有正在进行的 addObserver → 同步所有 Observer
    if (mAddingObserverCounter == 0) {
        sync();
    }
}

4.3 sync() --- 遍历所有 Observer 逐个同步

java 复制代码

// LifecycleRegistry.java
private void sync() {
    // ★ 遍历所有 Observer
    // mObserverMap 是 FastSafeIterableMap（有序的 HashMap）
    while (mObserverMap.size() > 0) {
        // 取第一个 Observer
        ObserverWithState observer = mObserverMap.eldest().getValue();

        // ★ 比较 observer 的状态和全局状态
        while (observer.mState.compareTo(mState) < 0) {
            // Observer 状态 < 全局状态 → 正向推进
            forwardPass(observer);
        }

        while (observer.mState.compareTo(mState) > 0) {
            // Observer 状态 > 全局状态 → 反向回退
            backwardPass(observer);
        }

        // 处理完一个，检查下一个
    }
}

sync() 的核心逻辑只有一句话：看每个 Observer 的当前状态和全局状态差多少，缺什么补什么。

五、forwardPass 与 backwardPass：事件补齐

5.1 forwardPass --- 正向推进

java 复制代码

private void forwardPass(LifecycleObserver observer) {
    // ★ 从 Observer 当前状态到目标状态，一级一级推进
    while (observer.mState.compareTo(mState) < 0) {
        // 根据 Observer 当前状态，算出需要发出什么事件
        Event event = upEvent(observer.mState);
        // 发出事件
        observer.dispatchEvent(event);
        // dispatchEvent 内部会更新 Observer 的状态
        // 然后继续循环，直到追上全局状态
    }
}

upEvent() 的映射：

Observer 当前 State	发出 Event
INITIALIZED	ON_CREATE
CREATED	ON_START
STARTED	ON_RESUME

示例：

scss 复制代码

Activity 刚 onCreate，状态为 CREATED
此时 addObserver
  → Observer 初始状态：INITIALIZED
  → 全局状态：CREATED
  → sync → forwardPass
    → upEvent(INITIALIZED) = ON_CREATE
    → 发 ON_CREATE → Observer.dispatchEvent(ON_CREATE)
      → Observer 状态推进到 CREATED
      → 回调 observer.onCreate()
    → 追上全局状态 → 结束

5.2 backwardPass --- 反向回退

java 复制代码

private void backwardPass(LifecycleObserver observer) {
    // ★ 从 Observer 当前状态反向回退到目标状态
    while (observer.mState.compareTo(mState) > 0) {
        // 根据 Observer 当前状态，算出需要发出什么事件
        Event event = downEvent(observer.mState);
        // 发出事件
        observer.dispatchEvent(event);
        // 继续循环，直到回退到全局状态
    }
}

downEvent() 的映射：

Observer 当前 State	发出 Event
RESUMED	ON_PAUSE
STARTED	ON_STOP
CREATED	ON_DESTROY

5.3 完整的事件 → 状态链条

复制代码

正向（启动）：
  INITIALIZED ──ON_CREATE──→ CREATED ──ON_START──→ STARTED ──ON_RESUME──→ RESUMED

反向（销毁）：
  RESUMED ──ON_PAUSE──→ STARTED ──ON_STOP──→ CREATED ──ON_DESTROY──→ DESTROYED

六、观察者注册：addObserver()

java 复制代码

// LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    // ① 计算初始状态
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    // ② 包装 Observer
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    // ③ 存入有序 Map
    mObserverMap.put(observer, statefulObserver);

    // ④ 判断是否需要补齐事件
    //    如果当前状态 > Observer 初始状态 → forwardPass
    if (mState.compareTo(INITIALIZED) > 0) {
        forwardPass(statefulObserver);
    }
}

不同时机 addObserver 的结果

addObserver 时机	Observer 初始状态	全局状态	forwardPass?	收到事件
onCreate 中	INITIALIZED	CREATED	✅	ON_CREATE → onCreate()
onStart 中	INITIALIZED	STARTED	✅	ON_CREATE → ON_START → onCreate() → onStart()
onResume 中	INITIALIZED	RESUMED	✅	ON_CREATE → ON_START → ON_RESUME → 全部收到
onPause 中	INITIALIZED	STARTED	✅	ON_CREATE → ON_START → onCreate() → onStart()
onStop 中	INITIALIZED	CREATED	✅	ON_CREATE → onCreate()
onDestroy 之前	INITIALIZED	CREATED	✅	ON_CREATE，后面还会收到 ON_DESTROY
onDestroy 之后	DESTROYED	DESTROYED	❌	无任何事件

特殊情况：onDestroy 中添加

分两种情况：

addObserver 在 super.onDestroy() 之前：

scss 复制代码

super.onDestroy() 还没调 → mState = CREATED
→ Observer 收到 ON_CREATE → onCreate() 回调
→ super.onDestroy() → handleLifecycleEvent(ON_DESTROY) → mState = DESTROYED
→ sync → backwardPass → 发 ON_DESTROY → onDestroy() 回调
→ Observer 收到：ON_CREATE, ON_DESTROY

addObserver 在 super.onDestroy() 之后：

ini 复制代码

super.onDestroy() 已调 → mState = DESTROYED
→ Observer 初始状态 = DESTROYED（因为 mState == DESTROYED）
→ Observer 状态 == 全局状态 → 不 forward，不 backward
→ Observer 收到：无任何事件

七、ObserverWithState.dispatchEvent() 与回调

java 复制代码

// LifecycleRegistry.java --- 内部类
static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    void dispatchEvent(LifecycleOwner owner, Event event) {
        // ★ 根据 Event 更新 Observer 自己的状态
        State newState = getStateAfter(event);
        mState = newState;

        // ★ 调用回调方法
        mLifecycleObserver.onStateChanged(owner, event);
    }
}

LifecycleEventObserver 的 onStateChanged 最终映射到具体的 lifecycle 方法：

java 复制代码

// 以 DefaultLifecycleObserver 为例
class DefaultLifecycleObserverAdapter implements LifecycleEventObserver {

    private final DefaultLifecycleObserver mObserver;

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mObserver.onCreate(source);
                break;
            case ON_START:
                mObserver.onStart(source);
                break;
            case ON_RESUME:
                mObserver.onResume(source);
                break;
            case ON_PAUSE:
                mObserver.onPause(source);
                break;
            case ON_STOP:
                mObserver.onStop(source);
                break;
            case ON_DESTROY:
                mObserver.onDestroy(source);
                break;
        }
    }
}

八、完整时序：Activity 从创建到销毁

scss 复制代码

Activity 构造
  → mState = INITIALIZED（但此时 LifecycleRegistry 刚创建，还没事件）

Activity.onCreate()
  → ReportFragment 注入 或 LifecycleCallbacks 注册
  → handleLifecycleEvent(ON_CREATE)
    → getStateAfter(ON_CREATE) = CREATED
    → moveToState(CREATED)
      → mState = CREATED
      → sync()
        → for each Observer:
          → Observer 状态 INITIALIZED < CREATED
          → forwardPass
            → upEvent(INITIALIZED) = ON_CREATE
            → dispatchEvent(ON_CREATE)
            → Observer.mState = CREATED
            → observer.onCreate()

Activity.onStart()
  → handleLifecycleEvent(ON_START)
    → getStateAfter(ON_START) = STARTED
    → moveToState(STARTED)
      → mState = STARTED
      → sync()
        → for each Observer:
          → Observer 状态 CREATED < STARTED
          → forwardPass
            → upEvent(CREATED) = ON_START
            → dispatchEvent(ON_START)
            → Observer.mState = STARTED
            → observer.onStart()

Activity.onResume()
  → handleLifecycleEvent(ON_RESUME)
    → ... 同理，Observer 收到 ON_RESUME → observer.onResume()

━━━━ 应用正常使用中 ━━━━

Activity.onPause()
  → handleLifecycleEvent(ON_PAUSE)
    → getStateAfter(ON_PAUSE) = STARTED
    → moveToState(STARTED)
      → mState = STARTED
      → sync()
        → for each Observer:
          → Observer 状态 RESUMED > STARTED
          → backwardPass
            → downEvent(RESUMED) = ON_PAUSE
            → dispatchEvent(ON_PAUSE)
            → Observer.mState = STARTED
            → observer.onPause()

Activity.onStop()
  → handleLifecycleEvent(ON_STOP)
    → ... Observer 收到 ON_STOP → observer.onStop()

Activity.onDestroy()
  → handleLifecycleEvent(ON_DESTROY)
    → ... Observer 收到 ON_DESTROY → observer.onDestroy()

九、状态驱动事件：核心设计哲学

Lifecycle 的设计可以概括为一句话：状态驱动事件。

不是"收到事件 → 更新状态"，而是反过来：

你决定要移动到哪个状态（moveToState），系统自动算出需要发出哪些事件，然后逐个回调 Observer。

scss 复制代码

Activity.onStart()                             程序员的代码
  │
  ▼
handleLifecycleEvent(ON_START)                 传入"事件"
  │
  ▼
getStateAfter(ON_START) = STARTED              算出"目标状态"
  │
  ▼
moveToState(STARTED)                           移动到目标状态
  │
  ▼
sync()                                          同步所有 Observer
  │
  forwardPass(observer)                         发现 Observer 需要推进
    │
    upEvent(CREATED) = ON_START                 算出需要发出的事件
      │
      dispatchEvent(ON_START)                   发出事件
        │
        observer.onStart()                      回调

这个设计解决了几个核心问题：

迟来的 Observer 也能收到正确的事件序列------通过 forwardPass 补齐缺失事件
一个 Event 对应两个 State------ON_STOP 和 ON_CREATE 都可以到达 CREATED，不用区分是"向上"还是"向下"
状态查询直观 ------getCurrentState().isAtLeast(STARTED) 直接比较枚举值即可

十、完整类关系图

kotlin 复制代码

interface LifecycleOwner                   interface LifecycleObserver
  └─ getLifecycle(): Lifecycle               (标记接口，无方法)
       │
       ▼                                   interface LifecycleEventObserver
abstract class Lifecycle                       └─ onStateChanged(owner, event)
  └─ addObserver(observer)
  └─ removeObserver(observer)              interface DefaultLifecycleObserver
  └─ getCurrentState(): State                  └─ onCreate / onStart / onResume / ...
       │
       ▼                                   interface FullLifecycleObserver
class LifecycleRegistry extends Lifecycle       (内部接口，所有 6 个方法)
  └─ mState: State
  └─ mObserverMap: FastSafeIterableMap<LifecycleObserver, ObserverWithState>
  └─ handleLifecycleEvent(event)
  └─ moveToState(state)
  └─ sync()
  └─ forwardPass(observer)
  └─ backwardPass(observer)
  └─ addObserver(observer)
  └─ removeObserver(observer)

class ObserverWithState
  └─ mState: State
  └─ mLifecycleObserver: LifecycleEventObserver
  └─ dispatchEvent(owner, event)

十一、总结

完整流程一句话

Activity 的生命周期事件通过 ReportFragment（API < 29）或 LifecycleCallbacks（API 29+）传入 handleLifecycleEvent() → 转换成目标 State → moveToState → sync() 遍历所有 Observer → 比较每个 Observer 的当前状态和目标状态的差距 → forwardPass 或 backwardPass 补齐事件 → 逐个回调 observer 的方法。

核心要点

State 和 Event 是两套体系 ，中间通过 getStateAfter() 和 upEvent() / downEvent() 互相转换
状态驱动事件------你设定目标状态，系统自动算事件
补齐机制------迟来的 Observer 通过 forwardPass 收到缺失的事件序列
有序分发 ------FastSafeIterableMap 保证 Observer 按注册顺序收到回调
容错处理------状态没变就不做任何事，防止重复分发

监听方式演进

阶段	方式	范围
Support Library 早期	ReportFragment	仅 FragmentActivity
AndroidX Activity 1.0 左右	ComponentActivity 直接重写生命周期方法	AndroidX 应用
现在（最新版）	API 29+ 用 LifecycleCallbacks，以下用 ReportFragment	所有 Activity

这就是 Android Lifecycle 的完整原理。它没有复杂的黑魔法，核心就是一个状态机 + 事件补齐的算法。