使用方法

LiveData可以看作是加上了生命周期的观察者模式实现。先看使用例子

private val data = MutableLiveData<User>()

data.observe(lifecycleOwner) {
    // TODO
}

// 发送数据
data.value = User()
// 异步发送数据
data.postValue(User())

源码分析

消费者

从observe看起，查看LiveData类中的observe方法

@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    // 只能在主线程监听
    assertMainThread("observe");
    // 如果lifecycle已经销毁，直接返回，不监听
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    // 将LifecycleOwner和Observer封装一下
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    // 添加Observer到HashMap中
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    // 如果已经存在同样的Observer,直接返回
    if (existing != null) {
        return;
    }
    // 给lifecycle添加一个Observer
    owner.getLifecycle().addObserver(wrapper);
}

从上可以得到，LifecycleBoundObserver一定继承了LifecycleObserver

class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
    @NonNull
    final LifecycleOwner mOwner;

    LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
        super(observer);
        mOwner = owner;
    }

    @Override
    boolean shouldBeActive() {
        // 关键代码，保证观察者收到值的时候，Activity一定是活跃的
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
        // Lifecycle状态为已经销毁，表示Activity已经销毁了
        if (currentState == DESTROYED) {
            // 移除监听
            removeObserver(mObserver);
            return;
        }
        Lifecycle.State prevState = null;
        while (prevState != currentState) {
            prevState = currentState;
            // 状态改变时，分发值
            activeStateChanged(shouldBeActive());
            currentState = mOwner.getLifecycle().getCurrentState();
        }
    }

    @Override
    boolean isAttachedTo(LifecycleOwner owner) {
        return mOwner == owner;
    }

    @Override
    void detachObserver() {
        mOwner.getLifecycle().removeObserver(this);
    }

LifecycleEventObserver实现

public interface LifecycleEventObserver extends LifecycleObserver {
    void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event);
}

从源码可以看到，LifecycleBoundObserver继承了存放了ObserverWrapper，实现了LifecycleEventObserver接口，并且存放了LifecycleOwner和Observer。
其中有一句关键代码是

mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED)

用于保证消费者始终在Activity活跃的时候收到值。

再看ObserverWrapper类做了什么

private abstract class ObserverWrapper {
    final Observer<? super T> mObserver;
    boolean mActive;
    int mLastVersion = START_VERSION;

    ObserverWrapper(Observer<? super T> observer) {
        mObserver = observer;
    }

    abstract boolean shouldBeActive();

    boolean isAttachedTo(LifecycleOwner owner) {
        return false;
    }

    void detachObserver() {
    }

    void activeStateChanged(boolean newActive) {
        if (newActive == mActive) {
            return;
        }
        // immediately set active state, so we'd never dispatch anything to inactive
        // owner
        mActive = newActive;
        changeActiveCounter(mActive ? 1 : -1);
        if (mActive) {
            // 分发值
            dispatchingValue(this);
        }
    }
}

大体功能是在状态改变时，调用dispatchingValue分发一下值，消费者分析到此结束，接下来分析设置了LiveData值后又做了哪些操作

生产者

• 同步方式

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

代码很简单，就是简单的设置了一下值，然后调用了dispatchingValue分发值，再翻翻dispatchingValue做了什么

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // 当前是否正在分发值，如果是，则直接返回
    if (mDispatchingValue) {
        mDispatchInvalidated = true;
        return;
    }
    mDispatchingValue = true;
    do {
        mDispatchInvalidated = false;
        // 第一次分发
        if (initiator != null) {
            considerNotify(initiator);
            initiator = null;
        } else {
            // 遍历Observer
            for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                considerNotify(iterator.next().getValue());
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    mDispatchingValue = false;
}

可以看到真正分发值的地方在considerNotify，再翻翻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);
}

代码很简单，就是从ObserverWrapper中取出了Observer，调用它的onChanged方法，分发值。

再看看异步发送值是怎么处理的

• 异步方式 postValue方法

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

使用ArchTaskExecutor post了一个mPostValueRunnable到主线程，那么看看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);
    }
};

mPostValueRunnable中从mPendingData取出了value，然后调用了同步的setValue方法。至此LiveData实现原理基本完毕，代码比较简单，源码只有一个文件。