【Jetpack】学穿：Lifecycle → 生命周期 (原理篇)-六虎

0x1、Lifecycle核心思想

本质上是围绕着这两个设计模式进行的：

模板模式 → 定义算法骨架，对外开放扩展点，基于继承关系实现，子类重写父类抽象方法；
观源码编辑器察者模式 → 对象间定义一对多的依赖，当一个对象状态发生改变，依赖对线程池象都会自动收到通知；

对这两种模式不了解的强烈建议看下笔者之前写的专栏：《把书读薄 | 设计模式之美》。

本节先肝下Lifecycle组件的两个库 lifecycle-common 和 lifecycle-runtime 的源码，了解实现原理，在事务所是干什么的肝Activity、Fragment中Lifecycle是如何发挥作用的。希望通过这节，能嵌套虚拟化让你事务在实际开中能够有的放矢，放心大胆地用上Lifecycle。

0x2、lifecycle-common 源码解读

lifecycle-common 包中包含下述文件事务，挑着看：

① Lifecycle抽象类

类中定义了生命周期源码之家事件和状态，先看 Event，枚举了7种生命周期事件：

ON_事务所所长的委托怎么接CREATE、ON_START、ON_RESUME、O事务所所长npcN_PAUSE、ON_STOP、ON_DESTROY、ON_ANY

定义了状态升级、降级的四个方法：

downFrom()、事务性工作是什么意思downTo()、upFrom()、upTo(源码交易平台)

这里的升降级，读者看了可能会有点懵，可以把之前那个图竖着看：

以downFrom()为例，从传入状态降级，返回对应State：

从CREATED往下走，调用OnDestory，从STARTED往下走，调用onStop()，从RESUME往下走，源码之家调用onPause()

嘿源码嘿，是不是一下子就看懂了，再看下downTo()：

往下走到DESTORYED，事务文书调用onDestory()，往下走到CR链表c语言EATED，调用onStop()，事务的意思剩下两个也是类似~

然后还有个 getTargetState()

这个就更好理解了，调用onCreate()、onStop()会处于CREATED状态，其他同理。

说完Event说State，更简单，定义了定义了5个状态的枚举事务所所长npc值：

D线程撕裂者ESTROYED、INITIALIZED、CREATED、STARTED、RE嵌套表格SUMED

以及一个判断状态是否相等的方法：

最后定义了三个抽象方法：

addObserver()、removeObserver()、getCurrentState()

可以把Lifecycle看作 抽象被观察者，抽取出生命周期事件与状态，统一状态流转过程，并提供了增删观察者的抽象方法供 具体被观察者 实现。

② LifecycleObserver接口

空接口，类型标记，可看作 抽象观察者

③ FullLifecycleObserver、LifecycleEvent事务文书Observer接口

都继承LifecycleObserver接口，提供了两类不同的回调：

一种嵌套if函数是详细的生命周期回调，一种是有状态变化链表和数组的区别就回线程池调，前者链表不具有的特点是优先级大于后者。

④ DefaultLifecycleObserver接口

继承 Ful源码资本lLifecycleObserver，这里用到了Java 8后才有的特性：接口声明默认方法，默认重写了回调方法，具体观察者 按需实现关注的回调方嵌套循环法即可。

public interface DefaultLifecycleObserver extends FullLifecycleObserver {
    @Override default void onCreate(@NonNull LifecycleOwner owner) { }
    @Override default void onStart(@NonNull LifecycleOwner owner) { }
    @Override default void onResume(@NonNull LifecycleOwner owner) { }
    @Override default void onPause(@NonNull LifecycleOwner owner) { }
    @Override default void onStop(@NonNull LifecycleOwner owner) { }
    @Override default void onDestroy(@NonNull LifecycleOwner owner) { }
}

⑤ LifecycleOwner接口

提供一个获取 L链表反转ifecycle 的方法：

⑥ Lifecycling类

将传入的 LifecycleObserver 进行类型包装，生成一个新的 LifecycleEventObserver 实事务所所长npc例，使得Event分发过程可以统一入口。直接关注 lifecycleEventObserver() ：

看下 FullLi源码资本fecycleO事务所是干什么的bserverAdapter：

就是套了一层，保证先执源码之家行FullLifec事务所所长npcycleObserver的回调，再执行Lifec源码时代ycle链表排序Even源码资本tObserver的回调。

注解反事务所射线程池的七个参数相源码编辑器关的暂且不看，基于OnLifecycleEvent注解方式进行回调，是面向基于J链表逆置ava 7作为编译版本的平台，现在基本都Java 8了，甚至有些玩Compose的都已经用上Java 11了。注释也有说，只是为了兼容保留，后续会逐步废弃。

lifecycle-common包看得差不多了，接下来看另一个~

0x3、lifecycle-runtime 源码解读

lifecycle-runtime 包含下述四个文件：

① LifecycleRegistry类

整个包里最链表数据结构重要的一个类，可看作 具体被观察者，常规玩法都是：

定义一个集合，存所有观察者，事件产生时，迭代集合，调用观察者对应的回调方法。

但在这里，逻辑变得更复杂事务了，因为还涉及到了 状态管理，还得考虑这些问题：

① 有事件产生迭代观察者事务所所长集合时，可能增删集合中的观察者 → 集合需要支持迭代时增删元素 → 你像ArrayList就不行，for迭代时移除元素会报线程是什么意思Co线程和进程的区别是什么ncurrentModificationException；
② 处理事件回调时，新加入的观察者该如何处理？链表和数组的区别该设置为什么状态？要不要也进行回调？
③ 如果移除观察者线程池呢？状态要更新吗？还是直接忽略？等等…

心中埋下这些问题的种子，然后开始跟源码，先是这个支持迭代时增事务隔离级别删元素的集合：

一眼就看到这个 FastSafeIterableM嵌套结构ap，点开类，注释说嵌套循环到：

简陋版的LinkedHashMap，支持遍历时的元素删除，比Saf嵌套ifeI链表数据结构terableMap占用更多事务所内存，非线程安全

他继承 SafeIterableMap(链表实现) 类，并重写了这四个方法

空间换时间，就是套了一层HashMap，使得 查找起来会更快 而链表已，接着看 SafeIterableMap

定义了头、尾Entry，存迭代器的WeakHashMap，节点计数器，看下 Entry

就是每个独立的 节点，里面除了key，value外，还有事务的四个特性前后节点的引用，继续看get()、和put()：

单链表的创建链表的常规操作了，而 pu线程池面试题tIfAbsent() 更简单，就是调get()，拿到元素直接返回，拿不到p嵌套函数ut()插入元素。

回到关注点：遍历时删除元素，跟下 remove()：

跟下 supportRemo线程的几种状态ve()：

关于迭代器具体的添加和删除，提供三个具体实现类：

AscendingIterator(升序)
DescendingIterator(降序)
Iterator事务所WithAdditions(还支持添加元源码网站素)

就不去抠了，在调用 iterator() 获源码得迭代器时，都会把迭代器添加到集合事务所是干什么的中：

移除的话就不牢费心了，因为是弱引用，GC会自动回收，关于这个迭代时可源码增删元素的集合就了解到这事务的四个特性。看回LifecycleRegistry：

key是LifecycleObs嵌套查询erver，Value是 ObserverWithState，看看定义：

就是状态与源码之家观察者进行关联，并提供统一的事件分发入口，接着看下啥时候加集合里了，搜下 putIfAbsent 定位到了 addObserver()

大体了解流程，有疑惑的应该是这个 可重入标记 和 sync()同步，看看都同步的啥吧：源码网站

看下降级、升级同步对应的两个方法：

所以sync()做的事情就是：让所有观察者完成状态迁移，并线程安全完成相应的事件分发，而同步事务所所长的委托怎么接完成的判断依据就是：首尾节点是否相等。

除了addObserver()事务所所长添加新Observer时会同步外，在生命周期事件迁移时也会同步，定线程撕裂者位到：

看到这里应该能fe嵌套是什么意思el到为什么需要 可重入 的标记了，如果没有的话，可能产生sync()嵌套：

moveToState(state1)
→ sync()
→ moveToState(state1)
  → sync()
addObserver()
→ addObserver()
  → sync()
→ sync()
addObserver()
→ moveToState()
  → sync()
→ sync()

最后都会走 最外层(顶层)的s源码编辑器手机版下载ync()，中间发生的sync() 完全没必要执行，减少不必要的迭代或错误，通过这三个字段配合来完成：mHandli线程的几种状态ngEvent、mNewEventOccurred、mAddingObserverCounter。

然后还有个属性还没弄清楚是干嘛的：

解释下：它为了解决链表的定义 事件嵌套 中 增加新观察者对观察者队列有序性的破坏。怎么说，看事务所所长的委托怎么接代码：

假如没线程有mParentStates，好像还正常，然后注释给了一个反嵌套查询例：

Observer1 在 onStart() 回调中把链表排序自己从集合中移除，然后添加了新的Obse线程是什么意思rver2；
假如集合中只有Observer1这个观察者，移除后集合就是空的，会导致Observer2直接更新到LifecycleRegister的STARTED状态；
但，此时Observer1的 onS源码网站tart() 回调还未执行完，而 Observer2 的 ON_START就回调执行完了，显然就违背了LifecycleR源码之家egistry的设计 → 观察者的同步是按照顺序执行嵌套函数的；

添加了这个属性，在执行观察者回调前 pushParentState() 暂存当前观察者，回调完后 popParentState() 移除观察者，然后执行 calculateTargetState() 时判断是否为空，不为空取出最后一个缓存的观察者，然后取：LifecycleRegister当前状态、previous当前状态、缓存观察者状态中的最小值链表的创建，作为当前事务所所长观察者的状态事务隔离级别。

关于 LifecycleRegistry 关键代码的的解析就这些，它还线程的几种状态对外暴露了几个线程是什么意思改变状态的方法：链表逆置

Activiyt和Fragme嵌套查询nt中就有用到，等下会碰到，先继续往下走~

② ReportFragment类

一个专门用于分发生命周期事件的无UI界面的Fra链表反转gment，入口方法 injectIfNeededIn()

很清晰明了，API版本大于等于29，直接使用 activity.register线程数越多越好吗ActivityLifecycleCallbacks()，重写生命周期回调方法源码时代进行事件分发：

API版本小于线程安全29，直接开启一个事务，新建一个Re线程数越多越好吗portFragment实例，添加到activ线程是什么意思ity上，在ReportFragment中已对生命周期回调方法进行了重写，完成事件分发：

然后 dispatch() 就是调下 LifecycleRegist事务文书ry.han源码网站dleL事务所所长npcifecycleEvent() 而已。

还定义了一个 ActivityInitializationListener 接口：

支持外部通过 setProcessListener() 传入自定链表义实现，在 lifecycle-process 源码中看到过：

留了个后门，源码之家让ProcessLifecyc链表的创建leOwner的onStart()和onResume()，嵌套if函数先于第一个Activity执行。

③ ViewTreeLifecycleOwner类

看着有点蒙？看下 set() 调用处的代码就知道了：

Component嵌套虚拟化Activity实现了LifecycleOwner接口，所以这里传入了 根视图 + ComponentActivity这个LifecycleOwner

而在调用 get() 传入view源码时代时，通过getParent()线程和进程的区别是什么一层层往上拿，直到获取到这个LifecycleOwner为止(也可源码资本能没有返回空)。

那这有什么用呢？简化代码！

View内部需要基于lifecycl嵌套函数e进行某些操作时，可以避免Lifecycle的层层传递，比如LiveData订阅。

0x4、Acti源码资本vity中的Lifecycle相关

实现了Lifecycle接口，没干啥活，毕竟生命周期事务性工作是什么意思事件分发的活都交给Rep源码编辑器手机版下载ortFragment了，直接贴相关代码~

// 定义一个LifecycleRegistry
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    ...
    ReportFragment.injectIfNeededIn(this);  // 使用Report分发生命周期事件
    ...
}
@Override
protected void onSaveInstanceState(@NonNull Bundle outState) {
    Lifecycle lifecycle = getLifecycle();
    if (lifecycle instanceof LifecycleRegistry) {
        // 设置mLifecycleRegistry当前状态为CREATED
        ((LifecycleRegistry) lifecycle).setCurrentState(Lifecycle.State.CREATED);
    }
    ...
}
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

0x5、Fr源码编辑器手机版下载agment中的Lifecycle相关

同样实现了LifecycleOwner接口，实例化了一个LifecycleRegistry用链表和数组的区别于生命周期事件转发。

有一点要注意，在大多数情况下F源码编程器ragment与其管理的View(视图)的生命周期是一致的，但存在特例：

Fragment被replace()时 → FragmentTransaction.detach() → 回调onDestroyView()销毁视图 → 不走onDestory() → 使得F嵌套循环ragment状态得以保事务留，当前内存空间得以释放，下次加载直接onCreateView()，速度更快。

这样的操作嵌套表格也导致了事务隔离级别Fragment的生命周期比View长，所以Fragment还定义了一个 FragmentViewL嵌套查询ifecycleOwner 来单独处理View的生命周期，官方文档有给出《Fragment lifecycle》给出嵌套结构了这样一张图：

源码注释中也有给出Fra事务的四个特性gment中管理的View：生命周期与Fragment自身回事务所调间的对应关系。

直接抠出来，源码编程器方便看：

onVie嵌套ifwStateRestored()后 → ON_CREATE
onStart()后 → ON_START
onResume()后 → ON_RESUME
onPause()前 → ON_PAUSE
onStop()前 → ON_STOP
onDe事务性工作是什么意思stroyView()前 → ON_DESTROY

可调用 getViewLifecycleOwner() 获得View的LifecycleOwner哈~

Fragment中涉及到状态流转的核心代码如下：

void performCreate(Bundle savedInstanceState) {
    if (Build.VERSION.SDK_INT >= 19) {
        mLifecycleRegistry.addObserver(new LifecycleEventObserver() {
            @Override
            public void onStateChanged(@NonNull LifecycleOwner source,
                    @NonNull Lifecycle.Event event) {
                if (event == Lifecycle.Event.ON_STOP) {
                    if (mView != null) {
                        mView.cancelPendingInputEvents();
                    }
                }
            }
        });
    }
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_CREATE);
}
void performStart() {
    mState = STARTED;
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_START);
    if (mView != null) {
        mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_START);
    }
}
void performResume() {
    mState = RESUMED;
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    if (mView != null) {
        mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
    }
}
void performPause() {
    if (mView != null) {
        mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    }
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_PAUSE);
    mState = AWAITING_ENTER_EFFECTS;
}
void performStop() {
    if (mView != null) {
        mViewLifecycleOwner.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    }
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_STOP);
    mState = ACTIVITY_CREATED;
}
void performDestroy() {
    mLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_DESTROY);
    mState = ATTACHED;
}

既有Fr嵌套是什么意思agment Lifecycle的State，又有ViewL事务所是干什么的ifec嵌套结构ycleOwner的State，还有Fragment自身的Sta源码编程器te，这个要区分哈：

另外，相比以前的源码，Fragment发生了较大的改动，比如状态管理相关的剥离到 FragmentStateManager 中了，笔者目前还不太了解，就不先不往下挖了，后续专门研究Fragment再说吧~

0x6、小结

关于源码的解析暂且到这里吧，Lifecycle的路数基本摸清了，小结下要点方便回顾：

① Lifecycle的核心思想是：模板模式 + 观察者模式；
② L线程是什么意思if嵌套函数ecycle抽象类：抽象被观察者，定义了两个生命周期相关的枚举 Event 和 St嵌套ate，统一了State升降级对应触发的Event(关联关系)，提供了添加、移除观察者，获取当前State的三个抽象方法；
③ LifecycleObserver：空接口，类型标记，抽事务所象观察者；
④ FullLifecycleObserver、LifecycleEventObserver：继承LifecycleObserver接口，提供两种不同的回调方式；
⑤ DefaultLifecycleObserver：继承FullLifecycleObserver，利用Java 8源码编程器特性【接口声明默认方法】，默认重写了回调方法，具体观察者；
⑥ LifecycleOwner：提供一个获取Lifecycle的方法；
⑦ Lifecy源码编辑器下载cling → 对传入LifecycleOwner进行统一的类型包链表和数组的区别装，使得Event分发过程得以统一入口；
⑧ LifecycleRegistry → 具体观察者，组件状态维护，使用自定义支持迭代时增删元素的 FastSafeI线程是什么意思ter源码网站ableM嵌套if函数ap (HashMap套链表) 保存观察者。键为LifecycleObserver，值为 ObserverWithS源码时代tate，其中包含观察者与状态关嵌套原理的例子联，并提供事件分发方法dispatc嵌套原理的例子hEvent()；
⑨ 通过三个变量：mHandlingEvent、mNewEventOccurred、mAddingObserv源码交易平台erCounter 的配合来解决 事件嵌套 引起的sync()多次执行；
⑩ 额外定义了一个 mParentStates 来解决 事件嵌套 中 增加新观察者对观察源码编辑器下载者队列有序性的破坏。

以上就是本节的全部内线程数越多越好吗容，后续肝多几个组件，再来个实战篇吧，谢谢~

Tips：关于Lifecy事务所是干什么的cle库的改动可以参见：Lifecycle，其他库链表不具有的特点是亦是如此~

参考文献：

官方文档：使嵌套表格用生命周期感知型组件处理线程撕裂者生命周期
官方文档：Fragm事务所所长npcent li链表反转fecycle
重学安卓：为你还原一个真实事务所所长npc的 Jetpack Lifecycle
Lifecycle之SafeIterableMap
带你理解Jetpack——Lifecycle篇
【Android】使用嵌套是什么意思ViewTreeLifecycleOwner获取Lifecycle
“终于懂了“系列：Jetpack AAC完整解线程数越多越好吗析（一）Lifecycle 完全掌握！
从源码看 Jetpack（1事务所）- Lifecycle 源码详解

【Jetpack】学穿：Lifecycle → 生命周期 (原理篇)