跳至主要內容

Lifecycle 原理与使用

2026/9/14大约 6 分钟

Lifecycle 原理与使用

面试高频指数：极高 Lifecycle 是 Jetpack 的基石组件，ViewModel、LiveData、协程都建立在它之上。

1. 为什么需要 Lifecycle

传统方式管理生命周期的问题：

Java
// ✗ 传统方式：手动管理，容易遗漏
public class MainActivity extends AppCompatActivity {

    private LocationListener locationListener;

    @Override
    protected void onStart() {
        super.onStart();
        if (locationListener != null) locationListener.start();   // 忘记判断状态
    }

    @Override
    protected void onStop() {
        super.onStop();
        if (locationListener != null) locationListener.stop();
    }
}

问题：

  • 回调遗漏 → 内存泄漏、崩溃。
  • 组件与 Activity 强耦合，无法复用。
  • 测试困难。

Lifecycle 的解决方案：组件自己声明"我需要在哪些生命周期做哪些事"，由系统自动回调。

这样定位、传感器、动画等"随界面存在"的组件，从"依赖具体 Activity 子类"变成"依赖抽象的 LifecycleOwner"，组件可复用、可测试，也不会因为漏写回调而泄漏。

2. 核心概念

2.1 三个角色

Lifecycle 用观察者模式把"生命周期"抽象成三个角色：Activity/Fragment 是事件源（LifecycleOwner），Lifecycle 对象是状态机（负责记录与派发），业务组件是观察者（LifecycleObserver）。业务方只与观察者接口打交道：

角色类职责
事件源LifecycleOwner拥有生命周期（Activity / Fragment）
状态机Lifecycle维护生命周期状态并派发事件
观察者LifecycleObserver订阅生命周期事件

2.2 状态与事件

理解 Lifecycle 的第一步是分清事件（Event）与状态（State）：事件是"发生了什么"（onCreate 回调触发 ON_CREATE），状态是"当前处于什么阶段"（事件发生后的结果）。同一个事件会从最高到最低的观察者依次派发，而状态则用于判断是否需要通知观察者：

事件（Event）：
ON_CREATE → ON_START → ON_RESUME → ON_PAUSE → ON_STOP → ON_DESTROY

状态（State）：
DESTROYED ← INITIALIZED ← CREATED ← STARTED ← RESUMED

对应关系：
| 状态        | 已触发事件                  |
|-------------|-----------------------------|
| CREATED     | ON_CREATE                   |
| STARTED     | ON_START                    |
| RESUMED     | ON_RESUME                   |

关键点：状态是"结果"，事件是"动作"。例如 ON_START 事件发生后，状态变为 STARTED。

2.3 状态机迁移图

状态迁移遵循严格的先后顺序，不允许跳跃（例如从 CREATED 直接到 RESUMED 不合法）。值得注意的是回退路径：ON_PAUSE/ON_STOP 事件会在界面不可见时触发，观察者在此释放重资源，这正是定位、传感器类组件防泄漏的关键：

3. 使用方式

3.1 实现 LifecycleObserver

最早的写法是实现 LifecycleObserver 接口 + @OnLifecycleEvent 注解，在注解上声明关心哪个事件。注册方式统一：lifecycle.addObserver(组件实例) 即可，组件内部自动完成"该做的事"：

Java
public class LocationManager implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void start() {
        // 开始定位
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    public void stop() {
        // 停止定位
    }
}

// 使用
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getLifecycle().addObserver(new LocationManager());
    }
}

3.2 现代写法：DefaultLifecycleObserver

@OnLifecycleEvent 已被废弃，原因是它依赖运行时注解反射、且无法在编译期校验事件参数。官方推荐的 DefaultLifecycleObserver 是普通接口——需要关心哪个生命周期就重写哪个方法，编译期类型安全，IDE 智能提示也更友好：

Java
public class LocationManager implements DefaultLifecycleObserver {

    @Override
    public void onStart(LifecycleOwner owner) {
        // 开始定位
    }

    @Override
    public void onStop(LifecycleOwner owner) {
        // 停止定位
    }
}

@OnLifecycleEvent 注解已废弃，推荐实现 DefaultLifecycleObserver 接口。

4. 原理分析

4.1 LifecycleRegistry 状态同步

LifecycleRegistry 是 Lifecycle 的默认实现，它的职责是"把生命周期事件转成状态，并同步给所有观察者"。整个派发链路如下：

Activity onStart()
  → ReportFragment（注入的生命周期宿主）分发 ON_START 事件
  → LifecycleRegistry.handleLifecycleEvent(ON_START)
  → 更新 mState 为 STARTED
  → 遍历 Observer，逐个回调 onStateChanged
  → 若 Observer 未同步（如新建），会同步上调到当前状态

4.2 状态回退同步

Java
// LifecycleRegistry 核心逻辑（伪代码）
private void sync() {
    while (!isSynced()) {
        mNewEventOccurred = false;
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            // 状态下降：倒序遍历，派发 ON_PAUSE / ON_STOP / ON_DESTROY
            backwardPass();
        } else {
            // 状态上升：正序遍历，派发 ON_CREATE / ON_START / ON_RESUME
            forwardPass();
        }
    }
}

4.3 使用 LinearLayout 的原因

  • ReportFragment：通过向 Activity 注入无 UI Fragment 来接收生命周期回调（API < 29 时）。
  • API 29+ 直接通过 ComponentActivity 自身的 LifecycleRegistry 分发。
  • 使用 LinearLayout 保证同步性：在真正执行 onCreate 之前完成状态更新。

5. 常见应用场景

Lifecycle 的典型价值在于"资源随界面生死"：摄像头在 onStart 打开、onStop 释放；轮询在 onResume 启动、onPause 停止；自定义 View 也可以实现 LifecycleOwner 让自己的状态可被观察。三个高频场景一起看：

Java
// 场景 1：摄像头/传感器释放
public class CameraController implements DefaultLifecycleObserver {
    @Override public void onStart(LifecycleOwner owner) { camera.open(); }
    @Override public void onStop(LifecycleOwner owner) { camera.release(); }
}

// 场景 2：定时器/轮询（Java 中用 ExecutorService 替代协程）
public class PollingManager implements DefaultLifecycleObserver {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();
    @Override public void onResume(LifecycleOwner owner) { startPolling(); }
    @Override public void onPause(LifecycleOwner owner) { stopPolling(); }
}

// 场景 3：自定义 View 感知生命周期
public class MyView extends View implements LifecycleOwner {
    private final LifecycleRegistry lifecycleRegistry = new LifecycleRegistry(this);
    @Override public Lifecycle getLifecycle() { return lifecycleRegistry; }
}

6. 高频面试题

Q1：Lifecycle 的观察者模式体现在哪？ A：LifecycleOwner 是事件源，Lifecycle 维护状态机，LifecycleObserver 是观察者。 状态变化时 LifecycleRegistry 遍历观察者列表并回调，观察者无需关心事件来自 Activity 还是 Fragment。

Q2：为什么 ViewModel 能感知生命周期而不泄漏？ A：ViewModel 不直接持有 Activity 引用。它通过 ViewModelStore 由 ViewModelStoreOwner （Activity/Fragment）管理，onDestroy 时调用 clear() 释放。同时用 Lifecycle 感知 ON_DESTROY 事件，但只在非配置变更的销毁时才清空。

Q3：ReportFragment 的作用？ A：Android 10 之前，ComponentActivity 通过注入无 UI 的 ReportFragment 接收生命周期 回调并同步给 LifecycleRegistry；Android 10+ 改为直接分发，ReportFragment 仅用于 ProcessLifecycleOwner 等场景。

Q4：自定义 LifecycleOwner 需要注意什么？ A：① 必须用 LifecycleRegistry 并在合适时机调用 handleLifecycleEvent； ② 状态迁移要遵循状态机顺序（不能跳跃）；③ 记住在 onDestroy 置为 DESTROYED。

Q5：ON_DESTROY 和 DESTROYED 状态的区别？ A：ON_DESTROY 是事件（正在销毁，回调观察者）；DESTROYED 是状态（已销毁完成）。 观察者在 ON_DESTROY 中应释放资源，此时生命周期即将结束。

7. 小结

  • Lifecycle = 状态机 + 观察者模式，解耦组件与生命周期。
  • LifecycleRegistry 保证状态同步（上升/回退遍历）。
  • 现代 API：DefaultLifecycleObserver，注解方式已废弃。
  • 它是 ViewModel、LiveData、协程的生命周期基础。
总访问量–|GitHub|MIT License
Copyright © 2026 WikiAndroid