Lifecycle使用与详解

wumingtao697
435 阅读4分钟

​

一、lifecycle是什么？

根据官方文档给出的解释：

生命周期感知型组件可执行操作来响应另一个组件（如 activity 和 fragment）的生命周期状态的变化。这些组件有助于您写出更有条理且往往更精简的代码，这样的代码更易于维护。

核心概念

  • 宿主（LifecycleOwner） ：具有生命周期的组件，如 Activity、Fragment、Service 和 Application。
  • 观察者（LifecycleObserver） ：监听宿主生命周期状态变化的组件。
  • 生命周期状态（State） ：包括 INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED 等，用于描述宿主的当前状态。
  • 生命周期事件（Event） ：如 ON_CREATE、ON_START 等，由宿主状态变化触发。

​编辑

为什么使用lifecycle？

避免内存泄漏
  • 自动解绑：当宿主（如 Activity）销毁时，Lifecycle 会自动通知观察者（Observer）释放资源，避免因忘记解绑导致的对象泄漏。
    示例：在 onResume() 中注册位置监听，传统方式需在 onPause() 中手动注销；而使用 Lifecycle，只需绑定到 ON_PAUSE 事件，自动触发注销。
减少模板代码
  • 解耦生命周期逻辑：将原本分散在 onCreate()、onStart() 等回调中的代码，封装到独立的 Observer 类中。
    示例：一个网络请求组件只需实现 LifecycleObserver，通过 @OnLifecycleEvent(Lifecycle.Event.ON_START) 注解自动在 onStart() 时启动请求，ON_STOP 时取消请求。
统一生命周期管理
  • 跨组件复用：任何依赖生命周期的模块均可通过 LifecycleOwner 接口获取生命周期状态，无需依赖 Activity/Fragment 的具体实现。
    示例：ViewModel 内部可通过 viewModelScope 自动关联宿主的生命周期，避免协程泄漏。

二、怎么使用Lifecycle

1）、添加依赖

implementation("androidx.lifecycle:lifecycle-runtime-ktx:$2.2.9")

在新版本中，AppCompatActivity的顶级父类ComponentActivity已经实现了LifecycleOwner接口

open class ComponentActivity() :
    androidx.core.app.ComponentActivity(),
    ContextAware,
    LifecycleOwner，
    ······

2）、基础使用

方式一：使用 @OnLifecycleEvent 注解

// 自定义 Observer 类
class MyLifecycleObserver : LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onCreate triggered")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onStart triggered")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onStop(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onStop triggered")
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onDestroy triggered")
    }
}

// 在 Activity/Fragment 中注册
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

方式二：推荐使用 DefaultLifecycleObserver

class MyLifecycleObserver : DefaultLifecycleObserver {
    override fun onCreate(owner: LifecycleOwner) {
        Log.d("Lifecycle", "onCreate triggered")
    }
    // 其他方法类似...
}

DefaultLifecycleObserver 是 LifecycleObserver 的子接口，提供预定义生命周期方法（如 onStart()），开发者直接覆盖所需方法，无需注解，代码简洁且类型安全，是官方推荐方式；而 LifecycleObserver 是标记接口，需通过 @OnLifecycleEvent 注解绑定事件，灵活性高但代码冗余、易出错。

对比：

  • DefaultLifecycleObserver 更直观、维护性强，适合现代项目；LifecycleObserver 适用于需自定义方法名的场景。
  • 前者依赖 Java 8+，后者需手动管理注解，存在维护成本。优先选择 DefaultLifecycleObserver。

3）、结合 ViewModel 和协程：自动管理协程生命周期

class MyViewModel : ViewModel(), LifecycleObserver {

    private val _data = MutableLiveData<String>()
    val data: LiveData<String> = _data

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun startLoading() {
        // 使用 viewModelScope，协程自动在 ViewModel 销毁时取消
        viewModelScope.launch {
            val result = fetchDataFromNetwork()
            _data.value = result
        }
    }

    private suspend fun fetchDataFromNetwork(): String {
        // 模拟网络请求
        delay(2000)
        return "Data loaded"
    }
}

// 在 Activity/Fragment 中绑定
class MainActivity : AppCompatActivity() {
    private val viewModel: MyViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        lifecycle.addObserver(viewModel) // 将 ViewModel 作为 LifecycleObserver
    }
}

4）、在 Service 中使用 Lifecycle

// 自定义 LifecycleService
class MyService : LifecycleService() {

    private val serviceObserver = object : DefaultLifecycleObserver {
        override fun onCreate(owner: LifecycleOwner) {
            startForeground(NOTIFICATION_ID, createNotification())
            startLocationTracking()
        }

        override fun onDestroy(owner: LifecycleOwner) {
            stopLocationTracking()
        }
    }

    override fun onCreate() {
        super.onCreate()
        lifecycle.addObserver(serviceObserver)
    }

    private fun startLocationTracking() {
        // 启动后台定位
    }

    private fun stopLocationTracking() {
        // 停止定位
    }
}

启动和停止服务

// 在 Activity 中启动服务
val serviceIntent = Intent(this, MyService::class.java)
ContextCompat.startForegroundService(this, serviceIntent) // Android 8.0+ 需使用 startForegroundService
// 或直接 startService(serviceIntent)（需自行处理前台通知）


// 在 Activity 中停止服务
val stopIntent = Intent(this, MyService::class.java)
stopService(stopIntent)

5）、结合LiveData实现自动生命周期感知

class UserProfileFragment : Fragment() {

    private val viewModel: UserProfileViewModel by viewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        // LiveData 仅在界面处于 STARTED 或 RESUMED 时更新 UI
        viewModel.user.observe(viewLifecycleOwner) { user ->
            updateUI(user)
        }
    }

    private fun updateUI(user: User) {
        // 更新界面
    }
}

注意：viewLifecycleOwner 确保仅在 Fragment 视图存活时更新 UI。

三、Lifecycle源码解析

1. 生命周期监听实现

在父类的onCreate方法中创建了一个ReportFragment空白界面，在 Activity 中注入一个无界面的 ReportFragment，以实现对生命周期事件的监听和分发。

override fun onCreate(savedInstanceState: Bundle?) {
        // Restore the Saved State first so that it is available to
        // OnContextAvailableListener instances
        savedStateRegistryController.performRestore(savedInstanceState)
        contextAwareHelper.dispatchOnContextAvailable(this)
        super.onCreate(savedInstanceState)
        ReportFragment.injectIfNeededIn(this)
        if (contentLayoutId != 0) {
            setContentView(contentLayoutId)
        }
    }

若 Android 10（API 29）及以上版本，直接通过 LifecycleCallbacks 注册 Activity 的生命周期回调，无需依赖 ReportFragment。若 Android 10（API 29）以下的版本，向 Activity 中添加一个无界面的 ReportFragment，通过该 Fragment 的生命周期回调间接监听 Activity 的生命周期事件。

        @JvmStatic
        public fun injectIfNeededIn(activity: Activity) {
            if (Build.VERSION.SDK_INT >= 29) {
                // On API 29+, we can register for the correct Lifecycle callbacks directly
                LifecycleCallbacks.registerIn(activity)
            }
            // Prior to API 29 and to maintain compatibility with older versions of
            // ProcessLifecycleOwner (which may not be updated when lifecycle-runtime is updated and
            // need to support activities that don't extend from FragmentActivity from support lib),
            // use a framework fragment to get the correct timing of Lifecycle events
            val manager = activity.fragmentManager
            if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
                manager.beginTransaction().add(ReportFragment(), REPORT_FRAGMENT_TAG).commit()
                // Hopefully, we are the first to make a transaction.
                manager.executePendingTransactions()
            }
        }
        companion object {
            @JvmStatic
            fun registerIn(activity: Activity) {
                activity.registerActivityLifecycleCallbacks(LifecycleCallbacks())
            }
        }

之所以会进行这两种情况区分，是因为 registerActivityLifecycleCallbacks 中的 onActivityPostXXX 和 onActivityPreXXX 等方法是 SDK 29 时新添加的方法。当版本小于 29 时，就还是需要通过 ReportFragment 来间接取得事件通知。

2. 事件分发流程

当SDK >= 29时

    @RequiresApi(29)
    internal class LifecycleCallbacks : Application.ActivityLifecycleCallbacks {
        override fun onActivityCreated(
            activity: Activity,
            bundle: Bundle?
        ) {}

        override fun onActivityPostCreated(
            activity: Activity,
            savedInstanceState: Bundle?
        ) {
            dispatch(activity, Lifecycle.Event.ON_CREATE)
        }

        override fun onActivityStarted(activity: Activity) {}

        override fun onActivityPostStarted(activity: Activity) {
            dispatch(activity, Lifecycle.Event.ON_START)
        }

       ·······

        override fun onActivityPreStopped(activity: Activity) {
            dispatch(activity, Lifecycle.Event.ON_STOP)
        }

        override fun onActivityStopped(activity: Activity) {}

        override fun onActivitySaveInstanceState(
            activity: Activity,
            bundle: Bundle
        ) {}

        override fun onActivityPreDestroyed(activity: Activity) {
            dispatch(activity, Lifecycle.Event.ON_DESTROY)
        }

        override fun onActivityDestroyed(activity: Activity) {}
    }

当Activity 的 onCreate、onStart、onResume 等方法被调用后，就会通过 dispatch(activity, Lifecycle.Event.ON_XXX) 方法发送相应的 Event 值，并在 onPause、onStop、onDestroy 等方法被调用前发送相应的 Event 值。

在dispatch方法中，判断 Activity 类型：如果 Activity 实现了 LifecycleRegistryOwner（旧版兼容接口），直接通过其 lifecycle 属性（即 LifecycleRegistry）处理事件。如果 Activity 是标准的 LifecycleOwner（如 AppCompatActivity），且其 lifecycle 是 LifecycleRegistry 类型，同样调用 handleLifecycleEvent 处理事件。最后调用handleLifecycleEvent将事件event传递出去。

        @JvmStatic
        internal fun dispatch(activity: Activity, event: Lifecycle.Event) {
            if (activity is LifecycleRegistryOwner) {
                activity.lifecycle.handleLifecycleEvent(event)
                return
            }
            if (activity is LifecycleOwner) {
                val lifecycle = (activity as LifecycleOwner).lifecycle
                if (lifecycle is LifecycleRegistry) {
                    lifecycle.handleLifecycleEvent(event)
                }
            }
        }

SDK < 29

当Activity调用生命周期时，由于 ReportFragment 是挂载在 Activity 身上，ReportFragment 本身的生命周期方法和所在的 Activity 是相关联的，则空白界面也会调用相应的生命周期，最终也是调用dispatch(Lifecycle.Event.ON_XXXX)方法来发送Event值的，后面的流程就和SDK>=29的一样了。

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

    override fun onResume() {
        super.onResume()
        dispatchResume(processListener)
        dispatch(Lifecycle.Event.ON_RESUME)
    }

    override fun onPause() {
        super.onPause()
        dispatch(Lifecycle.Event.ON_PAUSE)
    }

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

    override fun onDestroy() {
        super.onDestroy()
        dispatch(Lifecycle.Event.ON_DESTROY)
        // just want to be sure that we won't leak reference to an activity
        processListener = null
    }

    private fun dispatch(event: Lifecycle.Event) {
        if (Build.VERSION.SDK_INT < 29) {
            // Only dispatch events from ReportFragment on API levels prior
            // to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
            // added in ReportFragment.injectIfNeededIn
            dispatch(activity, event)
        }
    }

在handleLifecycleEvent中先检查主线程，确保线程安全，通过**event.targetState根据事件获取对应的状态，最后通过moveToState** 更新状态 。

    public actual open fun handleLifecycleEvent(event: Event) {
        enforceMainThreadIfNeeded("handleLifecycleEvent")
        moveToState(event.targetState)
    }
        public val targetState: State
            get() {
                when (this) {
                    ON_CREATE, ON_STOP -> return State.CREATED
                    ON_START, ON_PAUSE -> return State.STARTED
                    ON_RESUME -> return State.RESUMED
                    ON_DESTROY -> return State.DESTROYED
                    ON_ANY -> {}
                }
                throw IllegalArgumentException("$this has no target state")
            }

那我们来看看是怎么通过**moveToState** 更新状态的。

    private fun moveToState(next: State) {
        if (state == next) {
            return
        }
        check(!(state == State.INITIALIZED && next == State.DESTROYED)) {
            "State must be at least CREATED to move to $next, but was $state in component " +
                "${lifecycleOwner.get()}"
        }
        state = next
        if (handlingEvent || addingObserverCounter != 0) {
            newEventOccurred = true
            // we will figure out what to do on upper level.
            return
        }
        handlingEvent = true
        sync()
        handlingEvent = false
        if (state == State.DESTROYED) {
            observerMap = FastSafeIterableMap()
        }
    }

 通过 sync() 方法确保所有观察者状态与宿主一致。

private fun sync() {
    // 1. 获取关联的 LifecycleOwner，若已被回收则抛出异常（防止状态更新到已销毁的组件）
    val lifecycleOwner = lifecycleOwner.get()
        ?: throw IllegalStateException(
            "LifecycleOwner of this LifecycleRegistry is already " +
                "garbage collected. It is too late to change lifecycle state."
        )

    // 2. 循环处理，直到所有观察者的状态与当前组件状态完全同步
    while (!isSynced) {
        newEventOccurred = false // 重置新事件标记

        // 3. 处理「向后同步」场景：当前状态比最旧观察者的状态更旧（如从 RESUMED 回退到 STARTED）
        if (state < observerMap.eldest()!!.value.state) {
            backwardPass(lifecycleOwner) // 触发 ON_PAUSE/ON_STOP 等事件，回退观察者状态
        }

        // 4. 处理「向前同步」场景：当前状态比最新观察者的状态更新（如从 STARTED 推进到 RESUMED）
        val newest = observerMap.newest()
        if (!newEventOccurred && newest != null && state > newest.value.state) {
            forwardPass(lifecycleOwner) // 触发 ON_START/ON_RESUME 等事件，推进观察者状态
        }

        // 5. 若同步过程中有新事件到达（newEventOccurred = true），循环会继续处理新状态
    }

    // 6. 同步完成后，重置标记并更新状态流（供外部观察）
    newEventOccurred = false
    _currentStateFlow.value = currentState // 通知 StateFlow 观察者当前最新状态
}

 

  • 向前同步（如 CREATED → RESUMED）：按观察者添加顺序触发 ON_START、ON_RESUME 事件。
  • 向后同步（如 RESUMED → DESTROYED）：按逆序触发 ON_PAUSE、ON_STOP 事件。
// 向前同步：将观察者的生命周期状态推进到当前组件的状态（如从 CREATED → STARTED → RESUMED）
private fun forwardPass(lifecycleOwner: LifecycleOwner) {
    // 1. 使用「升序迭代器」按观察者添加顺序遍历（保证先添加的观察者先收到事件）
    @Suppress()
    val ascendingIterator: Iterator<Map.Entry<LifecycleObserver, ObserverWithState>> =
        observerMap.iteratorWithAdditions()

    // 2. 遍历所有观察者，直到全部同步或新事件中断
    while (ascendingIterator.hasNext() && !newEventOccurred) {
        val (key, observer) = ascendingIterator.next()

        // 3. 若观察者的状态落后于当前组件状态（需向前推进）
        while (observer.state < state && !newEventOccurred && observerMap.contains(key)) {
            // 记录父状态（用于嵌套状态校验，防止非法状态跳跃）
            pushParentState(observer.state)

            // 4. 计算下一步应触发的事件（如 observer.state=CREATED → event=ON_START）
            val event = Event.upFrom(observer.state)
                ?: throw IllegalStateException("no event up from ${observer.state}")

            // 5. 分发事件（如触发 ON_START），更新观察者状态
            observer.dispatchEvent(lifecycleOwner, event)

            // 清理父状态栈
            popParentState()
        }
    }
}

// 向后同步：将观察者的生命周期状态回退到当前组件的状态（如 RESUMED → STARTED → CREATED）
private fun backwardPass(lifecycleOwner: LifecycleOwner) {
    // 1. 使用「降序迭代器」按观察者添加顺序逆序遍历（保证后添加的观察者先收到事件）
    val descendingIterator = observerMap.descendingIterator()

    // 2. 遍历所有观察者，直到全部同步或新事件中断
    while (descendingIterator.hasNext() && !newEventOccurred) {
        val (key, observer) = descendingIterator.next()

        // 3. 若观察者的状态超前于当前组件状态（需向后回退）
        while (observer.state > state && !newEventOccurred && observerMap.contains(key)) {
            // 4. 计算下一步应触发的事件（如 observer.state=RESUMED → event=ON_PAUSE）
            val event = Event.downFrom(observer.state)
                ?: throw IllegalStateException("no event down from ${observer.state}")

            // 记录目标状态（用于校验，例如 ON_PAUSE 的目标状态是 STARTED）
            pushParentState(event.targetState)

            // 5. 分发事件（如触发 ON_PAUSE），更新观察者状态
            observer.dispatchEvent(lifecycleOwner, event)

            // 清理父状态栈
            popParentState()
        }
    }
}

dispatchEvent分发事件

        fun dispatchEvent(owner: LifecycleOwner?, event: Event) {
            val newState = event.targetState
            state = min(state, newState)
            lifecycleObserver.onStateChanged(owner!!, event)
            state = newState
        }

 

public fun interface LifecycleEventObserver : LifecycleObserver {
    /**
     * Called when a state transition event happens.
     *
     * @param source The source of the event
     * @param event The event
     */
    public fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event)
}

根据以上的内容我们可以根据以下的图片来看：

生命周期状态以一个单一路径在 INITIALIZED → CREATED → STARTED → RESUMED 之间前进（forward），再可逆地回退到 DESTROYED（backward）。

每一次状态推进或回退，都对应一个唯一的事件：

  • 推进（forward）时依次触发 ON_CREATE → ON_START → ON_RESUME；
  • 回退（backward）时依次触发 ON_PAUSE → ON_STOP → ON_DESTROY。

确保所有 Observer 的状态始终严格、有序地与宿主组件的生命周期状态保持一致。

​编辑

总结

Lifecycle 通过将宿主组件（Activity/Fragment/Service/Application）抽象为 LifecycleOwner ，并让业务逻辑以 DefaultLifecycleObserver 等观察者的形式注册，实现了生命周期感知的统一管理：它在 INITIALIZED→CREATED→STARTED→RESUMED 之间线性推进、可逆回退至 DESTROYED，每一步对应唯一事件（ON_CREATE、ON_START、ON_RESUME、ON_PAUSE、ON_STOP、ON_DESTROY），并通过 sync() 循环调用正序/逆序分发机制，确保所有观察者状态严格、无遗漏地与宿主同步；开发者只需在观察者内声明回调，便能自动解绑资源、结合 LiveData 和 viewModelScope 管理协程，显著减少模板代码、避免内存泄漏，并实现跨组件、跨版本的复用与兼容。

​

avatar
文章
阅读
粉丝