深入解析 Android Jetpack LiveData 的实现原理

public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    // 1. 如果LifecycleOwner处于DESTROYED状态，直接抛异常。
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        return;
    }

    // 2. 创建一个内部包装类：LifecycleBoundObserver
    // 它是 ObserverWrapper 的子类，并且实现了 LifecycleEventObserver 接口
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);

    // 3. 将 (observer, wrapper) 键值对添加到内部的 Map 结构 mObservers 中
    // mObservers 是 LiveData 内部维护的一个观察者列表（FastSafeIterableMap）
    // 如果 observer 已经存在，并且绑定的 LifecycleOwner 不同，则抛异常
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && !existing.is	(owner)) { // 检查是否重复注册且 owner 不同
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with a different lifecycle owner");
    }
    if (existing != null) { // 如果是同一个 observer 和 owner，则直接返回
        return;
    }

    // 4. 最关键的一步：将包装后的 LifecycleBoundObserver 添加为 LifecycleOwner 的生命周期观察者
    owner.getLifecycle().addObserver(wrapper);
}

// LiveData 的内部类，简化代码
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull final LifecycleOwner mOwner;

    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer); // 调用父类构造
        mOwner = owner;
    }

    // 接收生命周期事件回调
    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        // 如果 LifecycleOwner 已经 DESTROYED，则自动移除观察者
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            removeObserver(mObserver); // 调用 LiveData 的 removeObserver 方法
            return;
        }
        // 根据当前的生命周期状态，更新观察者的活跃状态
        activeStateChanged(mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED));
    }

    // 更新观察者的活跃状态，并可能触发数据分发
    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
}

// ObserverWrapper 内部也维护了一个 boolean mActive 字段
// boolean activeStateChanged(boolean newActive) 方法会根据 newActive 更新 mActive
// 并在 mActive 变为 true 时，调用 dispatchingValue(this) 尝试分发数据

protected void setValue(T value) {
    // 1. 确保在主线程调用，否则抛异常
    assertMainThread("setValue");

    // 2. 递增内部版本号 mVersion。这是防止重复分发和回溯更新的关键。
    mVersion++;
    // 3. 更新 LiveData 内部持有的最新数据
    mData = value;
    // 4. 开始分发数据给所有活跃的观察者
    dispatchingValue(null); // null 表示遍历所有观察者
}

protected void postValue(T value) {
    boolean postTask;
    // 1. 使用原子操作更新待处理数据 mPendingData
    synchronized (mDataLock) { // 简单锁，确保 mPendingData 的原子性
        postTask = mPendingData == NOT_SET; // 检查是否已有待处理的 postValue 任务
        mPendingData = value; // 设置新的待处理数据
    }

    // 2. 如果之前没有待处理的 postValue 任务，则提交一个 Runnable 到主线程
    if (!postTask) {
        return;
    }
    // 使用 ArchTaskExecutor 将任务提交到主线程
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

// 内部的 Runnable，会在主线程执行
private final Runnable mPostValueRunnable = new Runnable() {
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET; // 重置待处理数据标记
        }
        // 在主线程调用 setValue，完成实际的数据更新和分发
        setValue((T) newValue);
    }
};

// 简化后的 dispatchingValue 方法
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // 1. 阻止重入，防止在分发过程中 LiveData 再次被修改导致无限循环
    if (mDispatchingValue) {
        mDispatchingWhenPaused = true;
        return;
    }
    mDispatchingValue = true;

    // 2. 遍历观察者列表，根据 initiator 参数决定是遍历所有还是只处理特定观察者
    if (initiator != null) {
        considerNotify(initiator); // 只处理特定的观察者（例如刚变为活跃的）
    } else {
        // 遍历所有观察者
        for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                mObservers.iteratorWith  (); iterator.hasNext(); ) {
            considerNotify(iterator.next().getValue());
        }
    }
    mDispatchingValue = false;
}

// 实际通知观察者的方法
private void considerNotify(ObserverWrapper observer) {
    // 1. 检查观察者是否活跃
    if (!observer.mActive) {
        return; // 不活跃的观察者不通知
    }

    // 2. 检查观察者是否已经接收过当前版本的数据
    if (observer.mLastVersion >= mVersion) {
        return; // 已经接收过这个版本的数据，避免重复分发
    }
    observer.mLastVersion = mVersion; // 更新观察者已接收的版本号

    // 3. 通知观察者数据已更新
    observer.mObserver.onChanged((T) mData);
}