Lifecycle

Lifecycle 是什么？

Lifecycle 是Jetpack提供的生命周期感知型组件，核心目标是：

  1. 将Activity/Fragment的生命周期逻辑从组件（如ViewModel、Presenter、自定义管理器）中解耦；
  2. 让组件能自动感知宿主（Activity/Fragment）的生命周期变化，无需手动在 onCreate / onDestroy 等方法中调用组件的对应逻辑；
  3. 避免因忘记处理生命周期导致的内存泄漏、空指针等问题。

掌握Lifecycle的使用和原理，能让你写出更健壮、低耦合的Android代码，尤其是在复杂组件的生命周期管理上，能大幅减少内存泄漏和逻辑混乱问题。

被观察者：主要是activity和fragment，实现LifecycleOwner接口（Support Library 26.1.0 及更高版本中的 Fragment 和 Activity 已实现 LifecycleOwner接口），并且在初始化方法里添加观察者就行了。

Lifecycle 核心概念与使用方式

先掌握基础概念和常用用法，再深入原理，更易理解。

1.1 核心组件

组件作用
LifecycleOwner生命周期持有者（如Activity/Fragment），能提供自身的Lifecycle对象
Lifecycle存储宿主生命周期状态的核心类，对外暴露生命周期事件和状态
LifecycleObserver生命周期观察者，定义组件需要响应的生命周期事件（如onStart/onStop）
State宿主的当前生命周期状态（如INITIALIZED、CREATED、STARTED、RESUMED、DESTROYED）
Event触发状态变化的生命周期事件（如ON_CREATE、ON_START、ON_STOP、ON_DESTROY）

1.2 状态与事件的对应关系：

1.2.1 状态与事件的精准对应

生命周期状态核心特征对应的回调方法（事件）触发时机举例
初始态（不存在）无实例、无内存占用无App 未启动
创建态（Created）实例创建完成、不可见onCreate()首次启动 Activity、屏幕旋转重建
启动态（Started）界面可见、不可交互（如弹窗遮挡）onStart()从停止态恢复、首次创建后
运行态（Resumed）界面可见、可交互（前台活跃）onResume()从暂停态恢复、启动态后
暂停态（Paused）界面可见、失去焦点（如来电弹窗）onPause()跳转到其他 Activity、按 Home 键（第一步）
停止态（Stopped）界面完全不可见onStop()跳转到其他 Activity、按 Home 键（第二步）
销毁态（Destroyed）实例被回收、释放资源onDestroy()关闭 Activity、系统回收内存

1.2.2 关键补充（新手易混淆）

  • 重启场景：当 Activity 因屏幕旋转、内存不足被销毁后重建，会触发 onRestart() → onStart() → onResume()，其中 onRestart() 是 “停止态→启动态” 的专属事件，无对应独立状态。
  • 状态与事件的逻辑：状态是结果，回调方法是系统通知你状态变化的事件（你可以在事件方法中写业务逻辑，比如在onCreate()初始化控件、onPause()保存临时数据）。

1.3 基础使用：让组件感知生命周期

步骤1：添加依赖（Module级build.gradle）

dependencies {
    // Lifecycle核心依赖（AndroidX已默认集成，可显式声明）
    implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.7.0"
    // 若用注解方式（可选，推荐用KTX）
    implementation "androidx.lifecycle:lifecycle-common-java8:2.7.0"
}

步骤2：定义生命周期观察者（两种方式）

方式1：Kotlin 简洁写法（推荐）

利用lifecycle-runtime-ktx的扩展函数，无需实现接口：

// 自定义组件（如数据加载管理器）
class DataManager(private val lifecycle: Lifecycle) {
    init {
        // 关联生命周期，监听事件
        lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                when (event) {
                    Lifecycle.Event.ON_CREATE -> initData() // 宿主创建时初始化数据
                    Lifecycle.Event.ON_START -> startRefresh() // 宿主启动时开始刷新
                    Lifecycle.Event.ON_STOP -> stopRefresh() // 宿主停止时停止刷新
                    Lifecycle.Event.ON_DESTROY -> releaseResource() // 宿主销毁时释放资源
                    else -> {}
                }
            }
        })
    }

    private fun initData() { println("初始化数据") }
    private fun startRefresh() { println("开始刷新数据") }
    private fun stopRefresh() { println("停止刷新数据") }
    private fun releaseResource() { println("释放资源") }
}
方式2：注解方式（Java/Kotlin通用）
// 定义观察者（用@OnLifecycleEvent注解标记响应的事件）
class MyLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    fun onCreate() { println("宿主ON_CREATE") }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onStart() { println("宿主ON_START") }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    fun onDestroy() { println("宿主ON_DESTROY") }
}

步骤3：在Activity/Fragment中使用

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // 方式1：使用自定义DataManager
        val dataManager = DataManager(lifecycle)
        
        // 方式2：添加注解式观察者
        lifecycle.addObserver(MyLifecycleObserver())
    }
}

1.4 进阶使用：LifecycleService / ProcessLifecycleOwner

场景1：Service感知自身生命周期

class MyService : LifecycleService() {
    init {
        lifecycle.addObserver(object : LifecycleEventObserver {
            override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
                when (event) {
                    Lifecycle.Event.ON_CREATE -> println("Service创建")
                    Lifecycle.Event.ON_DESTROY -> println("Service销毁")
                    else -> {}
                }
            }
        })
    }
}

场景2：监听应用全局生命周期（前后台）

// 监听整个应用的生命周期（如应用进入前台/后台）
class AppLifecycleObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun onAppForeground() { println("应用进入前台") }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    fun onAppBackground() { println("应用进入后台") }
}

// 在Application中注册
class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        ProcessLifecycleOwner.get().lifecycle.addObserver(AppLifecycleObserver())
    }
}

Lifecycle 原理分析

2.1 核心设计：观察者模式 + 状态机

Lifecycle的底层是观察者模式的经典实现，结合状态机管理生命周期状态，核心流程如下：

步骤1：LifecycleOwner 提供 Lifecycle 对象

  • AndroidX的AppCompatActivity/Fragment已默认实现LifecycleOwner接口，重写getLifecycle()方法返回LifecycleRegistry（Lifecycle的核心实现类）；
  • LifecycleRegistry是状态和事件的管理者，负责存储当前状态、管理观察者、分发生命周期事件。

步骤2：宿主生命周期变化时分发事件

以Activity为例，AppCompatActivity的生命周期方法（如onCreate）会调用LifecycleRegistry的handleLifecycleEvent()方法分发事件：

// AppCompatActivity内部核心逻辑（简化）
@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 分发ON_CREATE事件，更新状态为CREATED
    getLifecycle().handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}

@Override
protected void onStart() {
    super.onStart();
    getLifecycle().handleLifecycleEvent(Lifecycle.Event.ON_START);
}

步骤3：LifecycleRegistry 通知所有观察者

LifecycleRegistry收到事件后，会：

  1. 更新自身的State（如从INITIALIZED→CREATED）；
  2. 遍历所有已注册的LifecycleObserver，调用其对应的事件处理方法；
  3. 保证事件分发的顺序与生命周期执行顺序一致，且线程安全（主线程执行）。

2.2 底层核心类实现（简化版）

1. LifecycleRegistry 核心逻辑

public class LifecycleRegistry extends Lifecycle {
    // 存储当前状态
    private State mState;
    // 存储所有观察者
    private List<ObserverWithState> mObservers;

    // 处理生命周期事件
    @Override
    public void handleLifecycleEvent(Event event) {
        // 1. 根据事件计算新状态
        State newState = getStateAfter(event);
        // 2. 更新状态
        moveToState(newState);
        // 3. 通知所有观察者
        sync();
    }

    // 通知观察者
    private void sync() {
        LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
        if (lifecycleOwner == null) {
            return;
        }
        // 遍历所有观察者，调用事件处理方法
        for (ObserverWithState observer : mObservers) {
            observer.dispatchEvent(lifecycleOwner, mState);
        }
    }

    // 添加观察者
    @Override
    public void addObserver(@NonNull LifecycleObserver observer) {
        // 封装观察者和初始状态
        ObserverWithState wrapper = new ObserverWithState(observer, mState);
        mObservers.add(wrapper);
        // 立即分发当前状态，保证观察者能拿到最新状态
        wrapper.dispatchEvent(mLifecycleOwner.get(), mState);
    }
}

2. ObserverWithState（观察者封装类）

class ObserverWithState {
    // 观察者实例
    final LifecycleObserver mObserver;
    // 观察者当前感知的状态
    State mState;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mObserver = observer;
        mState = initialState;
    }

    // 分发事件给观察者
    void dispatchEvent(LifecycleOwner owner, State eventState) {
        State newState = eventState;
        // 更新观察者状态
        mState = newState;
        // 根据观察者类型，调用对应方法
        if (mObserver instanceof LifecycleEventObserver) {
            // 处理LifecycleEventObserver（Kotlin常用）
            ((LifecycleEventObserver) mObserver).onStateChanged(owner, eventToEvent(newState));
        } else if (mObserver instanceof FullLifecycleObserver) {
            // 处理FullLifecycleObserver（系统内部使用）
            dispatchFullLifecycleEvent((FullLifecycleObserver) mObserver, newState);
        }
    }
}

2.3 关键细节：状态粘性

Lifecycle有一个重要特性：新注册的观察者会立即收到当前宿主的生命周期状态（即“粘性事件”）。

  • 例如：Activity已执行到ON_RESUME，此时注册观察者，观察者会立即收到ON_CREATE→ON_START→ON_RESUME的所有事件；
  • 原理：addObserver时，ObserverWithState会调用dispatchEvent，将当前mState分发给新观察者，保证观察者能感知到最新状态，无需担心注册时机。

Lifecycle 典型应用场景

  1. 数据加载：在ON_START时加载数据，ON_STOP时取消请求，避免后台请求返回后更新已销毁的UI；
  2. 资源管理：在ON_CREATE初始化播放器/定位，ON_DESTROY释放资源，避免内存泄漏；
  3. 与ViewModel配合：ViewModel通过Lifecycle感知宿主生命周期，实现数据的生命周期管理；
  4. 与LiveData配合：LiveData底层依赖Lifecycle，只向活跃状态（STARTED/RESUMED）的观察者分发数据，避免内存泄漏。

总结

  1. 核心作用：Lifecycle通过观察者模式解耦宿主生命周期与组件逻辑，让组件自动感知生命周期变化；
  2. 使用关键：
    • 宿主（Activity/Fragment）实现LifecycleOwner，提供Lifecycle；
    • 组件实现LifecycleObserver，注册到宿主的Lifecycle中；
  3. 原理核心：
    • LifecycleRegistry管理状态和事件分发，是核心调度类；
    • 宿主生命周期变化时分发Event，更新State并通知所有Observer；
    • 支持“状态粘性”，新观察者能立即拿到当前状态。
最近更新：:
Contributors: luokaiwen