Lifecycle

Lifecycles中文意思就是生命周期感知型组件，用来感知activity和fragment的生命周期的组件，主要运用观察者模式，Jetpack里很多组件都是基于Lifecycles来实现的，可以毫不夸张的说，Lifecycles是Jetpack的基础、是Jetpack组件库的重中之重。

基本使用

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

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

class MainActivity : BaseActivity() {

    companion object {

        const val TAG = "MainActivity"

        fun open(context: Context) {
            val intent = Intent(context, MainActivity::class.java)
            intent.flags = Intent.FLAG_ACTIVITY_CLEAR_TOP
            context.startActivity(intent)
        }
    }

    override fun layoutId(): Int {
        return R.layout.activity_main
    }

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

        ivIconBaidu.setOnClickListener {
            WebViewActivity.open(baseContext)
        }

        var basePresenter: BasePresenter<TextView> = BasePresenter();
        lifecycle.addObserver(basePresenter)
    }
}

观察者：实现LifecycleObserver接口，就能观测到被观察者的生命周期了，并且想观测哪些生命周期就运用哪个注解

public class BasePresenter<T> implements LifecycleObserver {

    private static final String TAG = "BasePresenter";

    /**
     * 绑定view
     */
    public void attachView(T view) {
        Log.e(TAG, "绑定了view");
    }

    /**
     * 解绑
     */
    public void detachView() {
        Log.e(TAG, "解绑了view");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void onCreateX(LifecycleOwner owner) {
        attachView(null);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void onStartX(LifecycleOwner owner) {
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void onStop(LifecycleOwner owner) {
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void onResume(LifecycleOwner owner) {
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void onPause(LifecycleOwner owner) {
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void onDestory(LifecycleOwner owner) {
        detachView();
    }


    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    void onAny(LifecycleOwner owner) {

    }
}

打印结果

绑定了view
解绑了view

打印结果和我们预期的也是一样的，到这里，我们Lifecycles的基本用法讲完了，那么Lifecycles是怎么实现监听生命周期变化的呢？其实内部和glide的生命周期监听也是类似的，其实就是在当前Activity或者fragment中绑定一个空的fragment来实现监听的。

源码分析

上面说过Support Library 26.1.0 及更高版本中的 Activity 已经实现 LifecycleOwner接口，所以先找实现LifecycleOwner接口的Activity的父类

public class ComponentActivity extends androidx.core.app.ComponentActivity implements
        LifecycleOwner,
        ViewModelStoreOwner,
        SavedStateRegistryOwner,
        OnBackPressedDispatcherOwner {

先进入接口LifecycleOwner看看

/**
 * A class that has an Android lifecycle. These events can be used by custom components to
 * handle lifecycle changes without implementing any code inside the Activity or the Fragment.
 *
 * @see Lifecycle
 */
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

我们发现里面就一个Lifecycle变量声明的方法getLifecycle，所有我们直接进入Lifecycle类，Lifecycle是个抽象类，我们查看里面的方法和变量

我们看到有Event，它里面包含了生命周期的一些事件的枚举，然后是State，它里面是一些状态的枚举。

构成 Android Activity 生命周期的状态和事件

您可以将状态State看作图中的节点，将事件Event看作这些节点之间的边，比如你执行ON_CREATE事件的时候，你的状态就会从INITIALIZED变为CREATED。还有addObserver添加和removeObserver删除观察者的方法，还有一个getCurrentState获取当前状态的方法，我们现进入addObserver方法看下

@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);

首先会获得初始状态值，如果是第一次进入肯定不等于DESTROYED，所以初始状态会是INITIALIZED，再把这个状态initialState和observer观察者放入ObserverWithState类型的变量statefulObserver里，最后再把statefulObserver和observer放进一个Map数组里mObserverMap，addObserver我们先看到这一步，因为再看下去我怕你们会懵逼，所以我们先直接到ComponentActivity的onCreate方法看

/**
 * {@inheritDoc}
 *
 * If your ComponentActivity is annotated with {@link ContentView}, this will
 * call {@link #setContentView(int)} for you.
 */
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    mSavedStateRegistryController.performRestore(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
    if (mContentLayoutId != 0) {
        setContentView(mContentLayoutId);
    }
}

我看进入ReportFragment.injectIfNeededIn(this)的方法里看下

public static void injectIfNeededIn(Activity activity) {
    // ProcessLifecycleOwner should always correctly work and some activities may not extend
    // FragmentActivity from support lib, so we use framework fragments for activities
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        // Hopefully, we are the first to make a transaction.
        manager.executePendingTransactions();
    }
}

我们看到injectIfNeededIn的作用就是把ReportFragment通过beginTransaction().add添加到Fragment管理器manager里面，我们再进入ReportFragment里看看

@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class ReportFragment extends Fragment {
    private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"
            + ".LifecycleDispatcher.report_fragment_tag";

    public static void injectIfNeededIn(Activity activity) {
        // ProcessLifecycleOwner should always correctly work and some activities may not extend
        // FragmentActivity from support lib, so we use framework fragments for activities
        android.app.FragmentManager manager = activity.getFragmentManager();
        if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
            manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
            // Hopefully, we are the first to make a transaction.
            manager.executePendingTransactions();
        }
    }

    static ReportFragment get(Activity activity) {
        return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
                REPORT_FRAGMENT_TAG);
    }

    private ActivityInitializationListener mProcessListener;

    private void dispatchCreate(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onCreate();
        }
    }

    private void dispatchStart(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onStart();
        }
    }

    private void dispatchResume(ActivityInitializationListener listener) {
        if (listener != null) {
            listener.onResume();
        }
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        dispatchCreate(mProcessListener);
        dispatch(Lifecycle.Event.ON_CREATE);
    }

    @Override
    public void onStart() {
        super.onStart();
        dispatchStart(mProcessListener);
        dispatch(Lifecycle.Event.ON_START);
    }

    @Override
    public void onResume() {
        super.onResume();
        dispatchResume(mProcessListener);
        dispatch(Lifecycle.Event.ON_RESUME);
    }

    @Override
    public void onPause() {
        super.onPause();
        dispatch(Lifecycle.Event.ON_PAUSE);
    }

    @Override
    public void onStop() {
        super.onStop();
        dispatch(Lifecycle.Event.ON_STOP);
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        dispatch(Lifecycle.Event.ON_DESTROY);
        // just want to be sure that we won't leak reference to an activity
        mProcessListener = null;
    }

    private void dispatch(Lifecycle.Event event) {
        Activity activity = getActivity();
        if (activity instanceof LifecycleRegistryOwner) {
            ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
            return;
        }

        if (activity instanceof LifecycleOwner) {
            Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
            if (lifecycle instanceof LifecycleRegistry) {
                ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
            }
        }
    }

    void setProcessListener(ActivityInitializationListener processListener) {
        mProcessListener = processListener;
    }

    interface ActivityInitializationListener {
        void onCreate();

        void onStart();

        void onResume();
    }
}

我们看到ReportFragment的生命周期里对应分发了Lifecycle里的那些枚举事件，所以activity生命周期发生变化的时候就会走ReportFragment的生命周期里的一些方法，所以我们再进入dispatch()方法

private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

dispatch方法里前面就是判断了activity是否有实现LifecycleRegistryOwner接口或者是LifecycleOwner接口（LifecycleRegistryOwner其实也是派生于LifecycleOwner的），如果是的话就进入执行handleLifecycleEvent方法，

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

一开始先通过getStateAfter获取当前状态的下一个状态

static State getStateAfter(Event event) {
    switch (event) {
        case ON_CREATE:
        case ON_STOP:
            return CREATED;
        case ON_START:
        case ON_PAUSE:
            return STARTED;
        case ON_RESUME:
            return RESUMED;
        case ON_DESTROY:
            return DESTROYED;
        case ON_ANY:
            break;
    }
    throw new IllegalArgumentException("Unexpected event value " + event);
}

看过前面那张状态和事件的枚举图现在来看这个getStateAfter方法就很好理解了把，例如如果你当前正在ON_CREATE或者ON_STOP，下一个状态就会走到CREATED状态。我们再把获得的下一个状态传到moveToState方法里，去真正移动到下一个状态

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        // we will figure out what to do on upper level.
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

如果下一个状态和当前状态相同就直接返回，否则执行sync()同步操作，我们再进入sync

private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
                + "garbage collected. It is too late to change lifecycle state.");
    }
    while (!isSynced()) {
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

在看这个同步方法之前，我们再来理解下那张状态图，

构成 Android Activity 生命周期的状态和事件

我们知道我们的activity随着用户的操作，状态会不断的改变，状态改变就会遵循上面这张图，比如onCreate跑完，状态就会变成created，如果执行完onStart，状态就会从created变成started，执行完onResune状态就会从started变成resumed以此类推。我们在前面代码知道，我们的观察者刚刚进来的初始换状态是INITIALIZED状态，所以观察者的状态可能和我们的activity的状态不一样，所以sync方法就是来让观察者和activity的状态同步的，我们再看到代码，里面主要是两个方法backwardPass和forwardPass，一个是向前移动，一个是向后移动，如果activity的状态是started，观察者的状态是created，那就要把观察者往后推；如果activity的状态是started，观察者的状态是resumed，那就要把观察者往前推。我们进入其中一个方法看看，我们进入backwardPass

private void backwardPass(LifecycleOwner lifecycleOwner) {
    Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
            mObserverMap.descendingIterator();
    while (descendingIterator.hasNext() && !mNewEventOccurred) {
        Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
        ObserverWithState observer = entry.getValue();
        while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
                && mObserverMap.contains(entry.getKey()))) {
            Event event = downEvent(observer.mState);
            pushParentState(getStateAfter(event));
            observer.dispatchEvent(lifecycleOwner, event);
            popParentState();
        }
    }
}

一开始就是拿到mObserverMap（所有观察者的map）的迭代器，然后循环每一个观察者，然后把被观察者lifecycleOwner和观察者的执行event 传入到dispatchEvent执行，我们进入dispatchEvent方法

static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

我们发现dispatchEvent是静态内部类ObserverWithState其中的一个方法，ObserverWithState类还记得么？就是前面我们把所有观察者和状态存起来的类，所以我们先看ObserverWithState的构造方法里的lifecycleEventObserver，我们发现lifecycleEventObserver最后都 return new ReflectiveGenericLifecycleObserver(object)到这里，所以我们直接进入

/**
 * An internal implementation of {@link LifecycleObserver} that relies on reflection.
 */
class ReflectiveGenericLifecycleObserver implements LifecycleEventObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

CallbackInfo getInfo(Class klass) {
    CallbackInfo existing = mCallbackMap.get(klass);
    if (existing != null) {
        return existing;
    }
    existing = createInfo(klass, null);
    return existing;
}

private CallbackInfo createInfo(Class klass, @Nullable Method[] declaredMethods) {
    Class superclass = klass.getSuperclass();
    Map<MethodReference, Lifecycle.Event> handlerToEvent = new HashMap<>();
    if (superclass != null) {
        CallbackInfo superInfo = getInfo(superclass);
        if (superInfo != null) {
            handlerToEvent.putAll(superInfo.mHandlerToEvent);
        }
    }

    Class[] interfaces = klass.getInterfaces();
    for (Class intrfc : interfaces) {
        for (Map.Entry<MethodReference, Lifecycle.Event> entry : getInfo(
                intrfc).mHandlerToEvent.entrySet()) {
            verifyAndPutHandler(handlerToEvent, entry.getKey(), entry.getValue(), klass);
        }
    }

    Method[] methods = declaredMethods != null ? declaredMethods : getDeclaredMethods(klass);
    boolean hasLifecycleMethods = false;
    for (Method method : methods) {
        OnLifecycleEvent annotation = method.getAnnotation(OnLifecycleEvent.class);
        if (annotation == null) {
            continue;
        }
        hasLifecycleMethods = true;
        Class<?>[] params = method.getParameterTypes();
        int callType = CALL_TYPE_NO_ARG;
        if (params.length > 0) {
            callType = CALL_TYPE_PROVIDER;
            if (!params[0].isAssignableFrom(LifecycleOwner.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. Must be one and instanceof LifecycleOwner");
            }
        }
        Lifecycle.Event event = annotation.value();

        if (params.length > 1) {
            callType = CALL_TYPE_PROVIDER_WITH_EVENT;
            if (!params[1].isAssignableFrom(Lifecycle.Event.class)) {
                throw new IllegalArgumentException(
                        "invalid parameter type. second arg must be an event");
            }
            if (event != Lifecycle.Event.ON_ANY) {
                throw new IllegalArgumentException(
                        "Second arg is supported only for ON_ANY value");
            }
        }
        if (params.length > 2) {
            throw new IllegalArgumentException("cannot have more than 2 params");
        }
        MethodReference methodReference = new MethodReference(callType, method);
        verifyAndPutHandler(handlerToEvent, methodReference, event, klass);
    }
    CallbackInfo info = new CallbackInfo(handlerToEvent);
    mCallbackMap.put(klass, info);
    mHasLifecycleMethods.put(klass, hasLifecycleMethods);
    return info;
}

其实一步步追踪进去ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());就是通过反射拿到带有那些注解的方法， mInfo.invokeCallbacks(source, event, mWrapped);就是最后真正执行那些注解方法的地方。

至此，我们已经分析完Lifecycles全部源码的，了解了Lifecycles的实际具体执行过程。

总结：

通过在被观察者的activity里套一个空的fragment来监听被观察者的生命周期，观察者实现LifecycleObserver然后通过注解获取一些和被观察者生命周期的一些监听方法，来实现观察者和被观察者的生命周期的统一。
一开始通过addObserver把观察者和它的初始状态放进一个数组里（因为观察者可能有好多个），然后在fragment的生命周期里会去调一个dispatch方法，把Event事件传进去，然后获取activity的下一个状态，（这个很好理解吧，因为随着用户的操作，actvity的状态是会不断改变的，比如你当前处于Created状态，如果用户操作了onCreate事件，actvity就从Created到达resumed状态了），然后会去同步观察者和activity的状态，然后去通过反射执行你注解了的方法，就可以在观察者里获取actvity的状态了
如果activity或者fragment生命周期变化Lifecycle通过反射获取观察者对象，调用标注了注解的方法。

核心说明：Lifecycle 是什么？

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

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

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

1. 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`）

状态与事件的对应关系：

INITIALIZED → ON_CREATE → CREATED → ON_START → STARTED → ON_RESUME → RESUMED
RESUMED → ON_PAUSE → STARTED → ON_STOP → CREATED → ON_DESTROY → DESTROYED

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

步骤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.3 进阶使用：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())
    }
}

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收到事件后，会：

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

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分发给新观察者，保证观察者能感知到最新状态，无需担心注册时机。

3. Lifecycle 典型应用场景

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

4. 总结

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