安卓面经（六）：Jetpack 篇|睡懒觉的随想录

Lifecycle

什么是 Lifecycle？

Lifecycle 是Jetpack 架构组件中的核心类，用于统一管理 Android 组件（Activity、Fragment 等）的生命周期，并通过观察者模式向外部暴露生命周期的变化。

传统上，我们需要在 onCreate、onStart、onDestroy 等方法里手动写逻辑，很容易产生内存泄漏或重复代码。而 Lifecycle 的引入，让我们可以只关心“生命周期状态的变化”，而不用和具体回调方法绑定。

Lifecycle 本质上就是一个抽象类，提供了注册和移除观察者的能力：

public abstract class Lifecycle {
    // 添加观察者
    public abstract fun addObserver(observer: LifecycleObserver)
    
    // 删除观察者
    public abstract fun removeObserver(observer: LifecycleObserver)
}

而 Activity、Fragment 等组件则实现了 LifecycleOwner 接口，要求提供一个 lifecycle 属性：

public interface LifecycleOwner {
    /**
     * 返回该组件的 Lifecycle
     */
    public val lifecycle: Lifecycle
}

这样一来，我们就能在任意地方对生命周期进行观察，而不必耦合到 Activity/Fragment 的具体方法中。

lifecycleScope

有了生命周期的监听机制，Google 官方进一步提供了协程作用域：lifecycleScope。它是 LifecycleOwner 的扩展属性，可以直接在 Activity 或 Fragment 中使用：

lifecycleScope.launch {
    // 在生命周期结束时自动取消
}

为什么会自动取消？因为在 LifecycleOwner.kt 中，Google 用 原子引用 + CAS 的方式，确保每个生命周期只持有一个唯一的 LifecycleCoroutineScope：

// LifecycleOwner.kt
public val LifecycleOwner.lifecycleScope: LifecycleCoroutineScope
    get() = lifecycle.coroutineScope

// Lifecycle.kt
public val Lifecycle.coroutineScope: LifecycleCoroutineScope
    get() {
        while (true) {
            val existing = internalScopeRef.get() as LifecycleCoroutineScopeImpl?
            if (existing != null) {
                return existing
            }
            val newScope = LifecycleCoroutineScopeImpl(
                this,
                SupervisorJob() + Dispatchers.Main.immediate
            )
            if (internalScopeRef.compareAndSet(null, newScope)) {
                newScope.register() // 将协程作用域注册到 Lifecycle
                return newScope
            }
        }
    }

LifecycleCoroutineScopeImpl 是 lifecycleScope 的实际实现。它本身就是一个 LifecycleEventObserver，会随着生命周期的变化自动管理协程：

internal class LifecycleCoroutineScopeImpl(
    override val lifecycle: Lifecycle,
    override val coroutineContext: CoroutineContext
) : LifecycleCoroutineScope(), LifecycleEventObserver {
    
    init {
        // 初始化时如果 Lifecycle 已经销毁，则立即取消协程
        if (lifecycle.currentState == Lifecycle.State.DESTROYED) {
            coroutineContext.cancel()
        }
    }
    
    fun register() {
        launch(Dispatchers.Main.immediate) {
            if (lifecycle.currentState >= Lifecycle.State.INITIALIZED) {
                lifecycle.addObserver(this@LifecycleCoroutineScopeImpl)
            } else {
                coroutineContext.cancel()
            }
        }
    }

    override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
        if (lifecycle.currentState <= Lifecycle.State.DESTROYED) {
            lifecycle.removeObserver(this)   // 移除观察者
            coroutineContext.cancel()        // 取消协程
        }
    }
}

总结：lifecycleScope 作用域会注册为观察者，当状态变为 DESTROYED 时自动取消协程，避免内存泄漏，开发者不再需要手动 cancel() 协程。