Android Lifecycle 总结

Created on April 29, 2026

2026   ·   android   jetpack   lifecycle   interview   ·   android

Android Lifecycle 总结

简洁结论：Lifecycle 是 Android Jetpack 中用于描述、感知和分发组件生命周期状态的基础组件。 它把 Activity、Fragment 等组件的生命周期抽象成统一的状态和事件模型，让业务对象可以解耦地感知生命周期变化，从而更安全地启动任务、停止任务、注册资源和释放资源。

1. What：它是什么？

Lifecycle 是 Jetpack Lifecycle 组件中的核心能力，用来表示一个 Android 组件当前所处的生命周期状态，并允许其他对象观察这个状态变化。

它通常包含几个关键角色：

  • LifecycleOwner：生命周期拥有者，例如 ComponentActivity、Fragment。
  • Lifecycle：生命周期对象，记录当前状态，并分发生命周期事件。
  • LifecycleObserver：生命周期观察者的基础接口。
  • DefaultLifecycleObserver：推荐使用的生命周期观察接口，提供 onCreate、onStart、onResume、onPause、onStop、onDestroy 等回调。
  • LifecycleEventObserver：更底层的事件观察接口，可以直接接收 Lifecycle.Event。
  • LifecycleRegistry：Lifecycle 的具体实现，常用于自定义 LifecycleOwner。

Lifecycle 中常见状态包括：

  • INITIALIZED
  • CREATED
  • STARTED
  • RESUMED
  • DESTROYED

常见事件包括：

  • ON_CREATE
  • ON_START
  • ON_RESUME
  • ON_PAUSE
  • ON_STOP
  • ON_DESTROY
  • ON_ANY

面试中可以一句话概括：Lifecycle 是 Android 对组件生命周期的标准化抽象，它让外部对象可以观察生命周期变化，而不是把所有生命周期逻辑都堆在 Activity 或 Fragment 的回调方法里。

2. Why：它解决了什么问题？

Lifecycle 主要解决 Android 生命周期管理复杂、组件耦合严重、资源释放容易遗漏的问题。

在没有 Lifecycle 感知组件时，很多代码会直接写在 Activity 或 Fragment 的生命周期方法中：

override fun onStart() {
    super.onStart()
    locationClient.start()
}

override fun onStop() {
    locationClient.stop()
    super.onStop()
}

这种写法可以工作，但有几个明显问题：

  • Activity/Fragment 很容易变成“上帝类”，UI 渲染、业务逻辑、资源管理全部混在一起。
  • 资源注册和释放容易不成对，例如注册监听器后忘记注销。
  • 定位、传感器、播放器、Flow 收集等任务可能在页面不可见后仍然运行。
  • 第三方组件或自定义组件很难独立感知宿主生命周期，只能依赖外部手动调用。
  • Fragment 有自身生命周期和 View 生命周期，处理不当容易导致 View 泄漏或空指针。

Lifecycle 的价值是：把生命周期变成一个可观察、可组合、可复用的模型。

典型使用场景包括：

  • LiveData 根据 Lifecycle 只向活跃页面分发数据。
  • 在 Activity/Fragment 中用 repeatOnLifecycle 安全收集 Flow。
  • 自定义播放器、定位管理器、传感器管理器根据生命周期自动启停。
  • Fragment 中使用 viewLifecycleOwner 观察只和 View 相关的数据。
  • 使用 ProcessLifecycleOwner 监听应用进入前台或后台。
  • 使用 lifecycleScope 让协程任务在生命周期销毁时自动取消。

3. How：它怎么使用？

3.1 使用 DefaultLifecycleObserver

推荐把和生命周期相关的逻辑封装到独立类中，然后让它实现 DefaultLifecycleObserver。

class LocationLifecycleObserver(
    private val locationClient: LocationClient
) : DefaultLifecycleObserver {

    override fun onStart(owner: LifecycleOwner) {
        locationClient.start()
    }

    override fun onStop(owner: LifecycleOwner) {
        locationClient.stop()
    }
}

在 Activity 或 Fragment 中注册：

class MapActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycle.addObserver(
            LocationLifecycleObserver(locationClient)
        )
    }
}

这样 Activity 不需要直接管理定位组件的启动和停止，定位组件可以随着宿主生命周期自动工作。

3.2 使用 LifecycleEventObserver

如果希望直接拿到具体事件，可以使用 LifecycleEventObserver：

class LogLifecycleObserver : LifecycleEventObserver {

    override fun onStateChanged(
        source: LifecycleOwner,
        event: Lifecycle.Event
    ) {
        Log.d("Lifecycle", "event = $event")
    }
}

注册方式一样：

lifecycle.addObserver(LogLifecycleObserver())

一般业务代码更推荐 DefaultLifecycleObserver，因为它类型更明确，可读性更好。

3.3 在 Fragment 中使用 viewLifecycleOwner

Fragment 有两个生命周期：

  • Fragment 自身的生命周期。
  • Fragment View 的生命周期。

如果观察结果会更新 View，应该使用 viewLifecycleOwner：

class UserFragment : Fragment(R.layout.fragment_user) {

    private val viewModel: UserViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewModel.userName.observe(viewLifecycleOwner) { name ->
            binding.userNameText.text = name
        }
    }
}

原因是 Fragment 实例可能还存在，但它的 View 已经被销毁。如果观察者绑定到 Fragment 自身生命周期，可能持有旧 View 或旧 Binding，从而引发内存泄漏或空指针问题。

面试中可以强调：只要观察回调里会操作 Fragment 的 View，就优先绑定 viewLifecycleOwner。

3.4 使用 repeatOnLifecycle 收集 Flow

在 Kotlin Flow 场景中，推荐使用 repeatOnLifecycle：

class UserFragment : Fragment(R.layout.fragment_user) {

    private val viewModel: UserViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        viewLifecycleOwner.lifecycleScope.launch {
            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
                viewModel.uiState.collect { state ->
                    render(state)
                }
            }
        }
    }
}

它的效果是：

  • 生命周期达到 STARTED 时开始执行代码块。
  • 生命周期低于 STARTED 时取消代码块。
  • 生命周期再次回到 STARTED 时重新启动代码块。
  • 生命周期进入 DESTROYED 后整体结束。

这比直接在 lifecycleScope.launch 中收集 Flow 更安全，因为直接收集可能在页面不可见时仍然运行。

3.5 使用 lifecycleScope

lifecycleScope 是绑定到 Lifecycle 的协程作用域。生命周期销毁时，作用域中的协程会自动取消。

class UserActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        lifecycleScope.launch {
            val user = repository.getUser()
            render(user)
        }
    }
}

需要注意：lifecycleScope 只负责在生命周期销毁时取消协程。如果希望页面不可见时停止收集 Flow，要配合 repeatOnLifecycle。

3.6 自定义 LifecycleOwner

如果自己实现一个有生命周期的组件，可以使用 LifecycleRegistry：

class CustomLifecycleOwner : LifecycleOwner {

    private val registry = LifecycleRegistry(this)

    override val lifecycle: Lifecycle
        get() = registry

    fun start() {
        registry.currentState = Lifecycle.State.STARTED
    }

    fun destroy() {
        registry.currentState = Lifecycle.State.DESTROYED
    }
}

这种场景不如 Activity/Fragment 常见，但能体现 Lifecycle 的本质：它不是只服务页面，而是一套通用的生命周期状态管理模型。

3.7 使用 ProcessLifecycleOwner

如果需要监听整个应用进入前台或后台，可以使用 ProcessLifecycleOwner：

class AppLifecycleObserver : DefaultLifecycleObserver {

    override fun onStart(owner: LifecycleOwner) {
        // 应用进入前台
    }

    override fun onStop(owner: LifecycleOwner) {
        // 应用进入后台
    }
}

注册：

ProcessLifecycleOwner.get().lifecycle.addObserver(
    AppLifecycleObserver()
)

典型场景包括埋点、前后台统计、全局资源暂停和恢复。但它表示的是进程级前后台生命周期，不适合替代具体页面生命周期。

4. Principle：它的核心原理是什么？

Lifecycle 的核心原理可以概括为：状态机 + 观察者模式 + 生命周期事件分发。

4.1 状态机

Lifecycle 会维护当前状态。以 Activity 或 Fragment 为例，组件从创建到显示，大致会经历：

INITIALIZED -> CREATED -> STARTED -> RESUMED

从前台退到后台，可能经历：

RESUMED -> STARTED -> CREATED

最终销毁时进入：

DESTROYED

这些状态不是孤立的，Lifecycle 会根据组件生命周期回调推动状态变化。

4.2 观察者模式

外部对象可以通过 addObserver() 注册到 Lifecycle 上：

lifecycle.addObserver(observer)

当 Lifecycle 状态变化时，它会通知观察者。

LifecycleOwner
      ↓ owns
Lifecycle
      ↓ dispatch event
LifecycleObserver

这样业务组件不需要被 Activity/Fragment 手动调用，只需要观察生命周期即可。

4.3 事件分发

Lifecycle 不只保存状态，还会分发事件。

例如：

  • onCreate() 对应 ON_CREATE
  • onStart() 对应 ON_START
  • onResume() 对应 ON_RESUME
  • onPause() 对应 ON_PAUSE
  • onStop() 对应 ON_STOP
  • onDestroy() 对应 ON_DESTROY

DefaultLifecycleObserver 会把这些事件映射成更直观的方法回调：

override fun onStart(owner: LifecycleOwner)
override fun onStop(owner: LifecycleOwner)

4.4 Fragment View Lifecycle 的特殊性

Fragment 的特殊点是它既有 Fragment 生命周期，也有 View 生命周期。

Fragment 实例可能还在，但它的 View 已经销毁。比如 Fragment 放入返回栈时，Fragment 对象可能仍然保留，但 View 会被销毁。

因此官方文档专门提供了 getViewLifecycleOwner() 和 getViewLifecycleOwnerLiveData()，用于管理 Fragment View 对应的生命周期。

这也是为什么在 Fragment 中观察 LiveData 或收集用于更新 View 的状态时，应该使用：

viewLifecycleOwner

而不是简单使用 Fragment 自身。

4.5 和 Jetpack 其他组件的关系

Lifecycle 是很多 Jetpack 组件的基础：

  • LiveData 依赖 Lifecycle 判断观察者是否活跃。
  • ViewModel 的作用域和 ViewModelStoreOwner 相关，也和生命周期体系协作。
  • lifecycleScope 依赖 Lifecycle 自动取消协程。
  • repeatOnLifecycle 基于 Lifecycle 在特定状态启动和停止协程任务。
  • Navigation 中的 back stack entry 也有自己的 Lifecycle。

所以面试中可以说：Lifecycle 是 Jetpack 架构组件能够生命周期感知的底层基础之一。

5. Trade-off：局限、缺点、常见坑和替代方案

Lifecycle 很重要，但它不是万能方案。

5.1 Lifecycle 只描述时机，不保证业务正确

Lifecycle 能告诉你组件处于什么状态，但不能替你决定业务任务应该如何处理。

例如页面停止时：

  • 普通 UI 数据收集可以停止。
  • 定位或传感器可以暂停。
  • 文件上传、支付、下载等任务不一定应该停止。

这些需要根据业务语义决定，而不是机械地跟着 Activity/Fragment 生命周期走。

5.2 Fragment 要区分 lifecycle 和 viewLifecycleOwner

这是 Android 面试高频追问点。

在 Fragment 中：

  • 和 Fragment 本身生命周期相关的逻辑，可以使用 lifecycle。
  • 和 View、Binding、UI 渲染相关的逻辑，应该使用 viewLifecycleOwner.lifecycle。

错误选择生命周期拥有者，容易导致 View 泄漏、旧 Binding 被引用、页面重建后回调异常。

还有一个特殊点：如果 DialogFragment 使用的是 Dialog 而不是自己的 View，那么不要盲目使用 viewLifecycleOwner，因为它可能没有常规 Fragment View 生命周期。

5.3 不推荐使用 OnLifecycleEvent

旧版本中可以通过 @OnLifecycleEvent 注解监听生命周期，但这种方式已经不推荐。现在更推荐：

  • DefaultLifecycleObserver
  • LifecycleEventObserver

接口方式更直接、类型更清晰，也更符合现在的 Jetpack 推荐写法。

5.4 repeatOnLifecycle 不要重复启动

repeatOnLifecycle 通常应该在 Activity 的 onCreate 或 Fragment 的 onViewCreated 中调用一次。

不要在会被频繁触发的方法里反复调用，否则可能创建多组重复收集任务，导致重复渲染或资源浪费。

5.5 lifecycleScope 不等于可见生命周期

lifecycleScope.launch 启动的协程会在 Lifecycle 销毁时取消，但不会因为页面进入 STOPPED 就自动暂停。

如果要在页面可见时收集，在页面不可见时停止，应使用：

repeatOnLifecycle(Lifecycle.State.STARTED)

或者在 Compose 中使用：

collectAsStateWithLifecycle()

5.6 Lifecycle 不能替代 ViewModel

Lifecycle 负责描述生命周期状态和事件；ViewModel 负责保存屏幕级 UI 状态和页面业务逻辑。

二者职责不同：

  • Lifecycle 解决“什么时候开始、停止、释放”。
  • ViewModel 解决“状态放在哪里、如何跨配置变化保留”。

5.7 Lifecycle 不能替代 WorkManager 或 Service

如果任务需要离开页面后继续执行，不能简单依赖 Activity/Fragment 的 Lifecycle。

例如：

  • 可靠后台同步。
  • 文件上传。
  • 大文件下载。
  • 定时任务。
  • 用户可感知的长时间任务。

更合适的选择可能是：

  • WorkManager
  • Service
  • ForegroundService
  • Repository 或应用级任务管理器

5.8 ProcessLifecycleOwner 不是精确页面生命周期

ProcessLifecycleOwner 用于感知应用进程整体前后台状态，适合埋点、全局资源管理等场景。

但它不能告诉你具体哪个页面可见，也不能替代 Activity 或 Fragment 的 Lifecycle。多进程应用中还需要额外注意它的进程范围。

5.9 类似技术对比

Lifecycle vs Activity/Fragment 生命周期回调

Activity/Fragment 的 onCreate、onStart、onStop 是原生回调；Lifecycle 是对这些回调的抽象和分发。Lifecycle 更适合把生命周期逻辑从 UI 控制器中拆出去。

Lifecycle vs ViewModel

Lifecycle 管理生命周期状态和事件；ViewModel 管理屏幕级 UI 状态和页面逻辑。ViewModel 可以配合 Lifecycle 使用，但不是 Lifecycle 的替代品。

Lifecycle vs LiveData

LiveData 使用 Lifecycle 判断观察者是否活跃。Lifecycle 是基础能力，LiveData 是基于它实现生命周期安全观察的一种数据容器。

Lifecycle vs lifecycleScope

lifecycleScope 是绑定到 Lifecycle 的协程作用域。Lifecycle 描述生命周期，lifecycleScope 负责在生命周期销毁时取消协程。

Lifecycle vs repeatOnLifecycle

repeatOnLifecycle 是基于 Lifecycle 的协程工具方法，适合在指定生命周期状态下启动和停止 Flow 收集。

Lifecycle vs ProcessLifecycleOwner

普通 Lifecycle 多用于 Activity/Fragment；ProcessLifecycleOwner 表示应用进程级别的前后台生命周期。

Lifecycle vs WorkManager

Lifecycle 适合页面或组件生命周期内的任务管理；WorkManager 适合需要可靠执行的后台任务。

面试口述版

Lifecycle 是 Android Jetpack 中对组件生命周期的标准化抽象，它通过 LifecycleOwner、Lifecycle 和 LifecycleObserver 把 Activity、Fragment 等组件的生命周期状态暴露出来，让外部对象可以解耦地感知生命周期变化。它解决的核心问题是生命周期逻辑分散、资源注册释放容易遗漏、Activity 或 Fragment 代码过重等问题。使用上可以让自定义组件实现 DefaultLifecycleObserver，然后通过 lifecycle.addObserver 注册；在 Fragment 更新 UI 时要优先使用 viewLifecycleOwner；在 Flow 场景中推荐用 repeatOnLifecycle 按生命周期安全收集数据。原理上，Lifecycle 本质是一个状态机加观察者模式，宿主生命周期变化时会更新当前状态，并把 ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY 等事件分发给观察者。它的局限是只能描述生命周期时机，不能替代业务状态管理、后台任务管理或数据层设计；复杂 UI 状态应该交给 ViewModel，长期后台任务应该考虑 WorkManager 或 Service。

参考资料

  • Android Developers: Lifecycle API reference
    https://developer.android.com/reference/androidx/lifecycle/Lifecycle
  • Android Developers: DefaultLifecycleObserver API reference
    https://developer.android.com/reference/androidx/lifecycle/DefaultLifecycleObserver
  • Android Developers: repeatOnLifecycle API reference
    https://developer.android.com/reference/androidx/lifecycle/RepeatOnLifecycleKt
  • Android Developers: Fragment lifecycle
    https://developer.android.com/guide/fragments/lifecycle
  • Android Developers: ProcessLifecycleOwner API reference
    https://developer.android.com/reference/androidx/lifecycle/ProcessLifecycleOwner


Enjoy Reading This Article?

Here are some more articles you might like to read next:

  • Android ViewModel 总结
  • Android Retrofit 总结
  • Android OkHttp 总结
  • Android MutableStateFlow 总结
  • Android LiveData 总结