前言

大家好，我是小益！使用Jetpack全家桶的同学相信对LiveData都不陌生，其可以在很大程度上避免内存泄漏、更好的将View层与Model层分离等诸多优点使得LiveData在MVVM模式中开发成为不可或缺的利器。今天我们就将LiveData剖开来瞧瞧，为何它这么香！

推荐

文章将率先在公众号「码途有道」上发布，欢迎大家关注！

一、LiveData的常用方法

LiveData主要是基于观察者机制实现的，LiveData是被观察者，其观察者是Observer，当LiveData有数据变动时会通知它的观察者去更新数据。LiveData常用的几个方法如下：

• setVaule
• postValue
• observe
• observeForever

二、setValue

setVaule与postVaule都是用来修改LiveData的值的，我们先看setValue的源码：

@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    mVersion++;
    mData = value;
    dispatchingValue(null);
}

在上述代码中有一个@MainThread注解，表示setValue只能在主线程中调用，并且在方法开头还有一句assertMainThread("setValue")来判断当前调用是否是在主线程中进行，如果不是在主线程则会抛出异常。

mVersion++用于记录LiveData是否有更新，每有一次更新，mVersion都会加一，在后续会使用到。

mData = value非常好理解，只是简单的记录需要更新的值。

dispatchingValue(null)用于通知观察者更新数据，源码如下：

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true;
    do {
        mDispatchInvalidated = false;
        if (initiator != null) {
            considerNotify(initiator);
            initiator = null;
        } else {
            for (Iterator<Map.Entry<Observer<? super T>, 
            ObserverWrapper>> iterator = mObservers.iteratorWithAdditions();
            iterator.hasNext();
            ) {
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

dispatchingValue(@Nullable ObserverWrapper initiator)传入的参数是观察者，如果有观察者传入，只通知这个传入的观察者进行数据更新，否则会遍历该LiveData下所有的观察者，并一一通知更新。在上述代码中真正去通知观察者进行数据更新的是considerNotify()方法，源码如下：

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {
        return;
    }
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    observer.mObserver.onChanged((T) mData);
}

源码中的流程非常简单：

• 首先通过观察者的mActive属性判断是否处于活跃状态；如果活跃继续往下走，否则到此结束。
• 之后通过观察者的shouldBeActive()方法判断其所在页面是否处于活跃状态（比如观察者所在的页面已经走到onDestory函数，那么页面就不是处于活跃状态）,如不处于活跃状态则需要将观察者自身的状态修改为非活跃状态。
• 如处于活跃状态，再通过将观察者自己的mLastVersion与LiveData的mVersion进行对比，若mLastVersion >= mVersion则代表没有更新，否则就是有更新。
• 最后，若有更新，则观察者会修改自己的mLastVersion并调用onChanged()方法做数据更新处理。

三、postValue

static final Object NOT_SET = new Object();
volatile Object mPendingData = NOT_SET;

protected void postValue(T value) {
    boolean postTask;
    synchronized (mDataLock) {
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    if (!postTask) {
        return;
    }
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

private final Runnable mPostValueRunnable = new Runnable() {
    @SuppressWarnings("unchecked")
    @Override
    public void run() {
        Object newValue;
        synchronized (mDataLock) {
            newValue = mPendingData;
            mPendingData = NOT_SET;
        }
        setValue((T) newValue);
    }
};

上面是postValue的相关源码，我们先理一下逻辑：mPendingData的初始值是NOT_SET，每当有更新时，mPendingData会记录新的value，之后post一个Runnable交给主线程处理，Runnable内部会调用setValue来更新数据，并且将mPendingData的值重新置为NOT_SET。

postValue与setValue相比，postValue可以在任意线程中调用，而setValue只能在主线程中调用，但是postValue内部最终还是通过调用setValue来实现数据更新。

postValue有一点需要注意：多次调用postValue，只有最后一次调用时传入的值有效。因为在postValue源码中，是通过mPendingData来记录需要更新的值，并通过mPendingData == NOT_SET来决定是否需要更新；但在更新未结束前，mPendingData不等于NOT_SET，即不能提交新的Runnable，而mPendingData的值却可以被更新，所以更新时获取的就是最后一次传入的值。

四、observer.shouldBeActive()

在上述提到的considerNotify()方法中，有一个shouldBeActive()方法，此方法属于观察者，用于判断观察者所在页面是否处于活跃状态。而在LiveData中，共有两种观察者：LifecycleBoundObserver与AlwaysActiveObserver。

4.1 LifecycleBoundObserver与observe

LifecycleBoundObserver是带有对所在页面生命周期判断的观察者，与LiveData的observe()方法联用（observe()内部调用的是LifecycleBoundObserver），源码如下：

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    ......
    @Override
    boolean shouldBeActive() {
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }
    ......
}

在LifecycleBoundObserver的shouldBeActive()方法中，会判断页面至少要处于STARTED状态才认为是处于活跃状态，即当Activity处于onStart()与onPause()之间则认为处于活跃状态。以下是状态源码：

public enum State {
        // onDestroy()
        DESTROYED,
        INITIALIZED,
        // 介于 onCreate() -- onStop() 之间
        CREATED,
        // 介于 onStart() -- onPause() 之间
        STARTED,
        // onResume()
        RESUMED;
    public boolean isAtLeast(@NonNull State state) {
    }
}

综上可得，正因为LifecycleBoundObserver中shouldBeActive()方法的实现，才使得LiveData具有可以避免内存泄漏的能力。

4.2 AlwaysActiveObserver与observeForever

AlwaysActiveObserver作为LiveData中的另一种观察者，与observeForever()方法联用（observeForever()内部调用的是AlwaysActiveObserver），其shouldBeActive()直接返回true，源码如下：

private class AlwaysActiveObserver extends ObserverWrapper {
    ......
    @Override
    boolean shouldBeActive() {
        return true;
    }
}

如此一来，使用observeForever()方法进行订阅后，便没有了对当前页面进行生命周期判断的能力；每当有数据变动时，都会通知观察者进行更新处理。使用此方法，需要注意内存泄漏问题。

五、小结

本章内容主要讲解LiveData的内部观察者机制，让大家使用时更加了然于心。LiveData除了作为MVVM模式中的重要一环之外，现在很多开发者还将其用作应用内的通信手段，后续文章我们将会介绍如何使用LiveData搭建通讯框架。