LiveData是一个抽象类，那么我们从简单的MutableLiiveData开始剖析，先看源码

源码太简洁了，就是继承LiveData，然后重写了父类的方法，并且没有多余的操作，都是直接使用父类方法里的逻辑，那我们就根据这几个方法，来一点一点看liveData

构造函数，也就是传一个泛型T的对象

 就是做一个初始化赋值，有一个mVersion = START_VERSION+1,也很好理解了

来到postValue

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

synchronized对这个代码块上锁，代码块里就是赋值，防止多个线程同时赋值，所以要上锁，第一次的时候mPendingData == NO_SET肯定是true,因为初始化的时候

volatile Object mPendingData = NOT_SET;

然后给mPendingData赋新值，然后post一个任务，这个任务的代码如下

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

同样要上锁，防止多线程同时修改值，将mPendingData赋值给newValue，然后又mPendingData = NOT_SET，这里其实有个线程切换，后面剖析，这里及继续追踪到setValue

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

有个注解@MainThread，也就是说这个方法一定要在主线程中调用，方法就是将值赋值给mData，这个mData就是构造方法里的mData，它一直在主线程更新，也就是说就算有多线程更新，那么也是一次一次的切换到主线程再更新mData的值

dispatchingValue()的核心代码

        do {mDispatchInvalidated = false;if (initiator != null) {considerNotify(initiator);initiator = null;} else {//遍历观察者，分别通知他们for (Iterator, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {considerNotify(iterator.next().getValue());if (mDispatchInvalidated) {break;}}}} while (mDispatchInvalidated);

其实就是观察者，然后通知他们，通知的方法considerNotify

 private void considerNotify(ObserverWrapper observer) {if (!observer.mActive) {  //判断观察者是否处于活跃状态return;}if (!observer.shouldBeActive()) {observer.activeStateChanged(false);return;}if (observer.mLastVersion >= mVersion) {    //记得versionCode不，这是一个判断是否匹配return;}observer.mLastVersion = mVersion;  //versionCode不同，就赋值 observer.mObserver.onChanged((T) mData);    //通知观察者更新}

构建liveData的观察者：

//构建liveData的观察者，这里为什么要传一个LifecycleOwner呢，其实就是要知道LifecycleOwner 的生 //命周期，因为liveDta是在activty/fragment在活跃状态的时候才会更新值，也就是说其实liveData也观察了activity/fragment的生命周期
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {@NonNullfinal LifecycleOwner mOwner;//构造函数LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer observer) {super(observer);mOwner = owner;}@Overrideboolean shouldBeActive() {return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);    //判断被观察者的最新状态}//观察了lifecycleOwner的生命周期状态，所以说虽然liveData是被观察者，但是它作为被观察者通样也是一个观察者@Overridepublic void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {//页面当前状态Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();if (currentState == DESTROYED) {    //页面都没了removeObserver(mObserver);return;}Lifecycle.State prevState = null;//状态改变while (prevState != currentState) {prevState = currentState;activeStateChanged(shouldBeActive());currentState = mOwner.getLifecycle().getCurrentState();}}@Overrideboolean isAttachedTo(LifecycleOwner owner) {return mOwner == owner;}@Overridevoid detachObserver() {        //不用观察了mOwner.getLifecycle().removeObserver(this);}}

其实liveDta是作为一个被观察者，当它的mData发生有效改变的时候，通知他的观察者集合们，同时liveData也是一个观察者啊，它时刻观察者当前activity/fragment的生命周期变化

------------------------------------------------------------

回到postValue，我们都知道在主线程更新liveData可以用setValue，但是在非主线程要更改liveData的值，需要用postValue，我们在上面看到了，就算用postValue，最终也是切到主线程调用setValue，那么我们就来追踪一些这个切换的过程

 因为在子线程中调用，所以我们先锁住我们的判断，防止值被改变，导致判断不准确，当值是改变了，那么核心就来到了

 ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

我们在子线程，这里有个postToMainThread，我们都知道线程的切换怎么都离不开handler,继续追踪，getInstance，会不会是一个单例呢，没错就是一个单例，切线程的方法postToMainThread

追踪发现一个DefaultTaskExecutor

    @Overridepublic void postToMainThread(Runnable runnable) {if (mMainHandler == null) {synchronized (mLock) {if (mMainHandler == null) {mMainHandler = createAsync(Looper.getMainLooper());}}}//noinspection ConstantConditionsmMainHandler.post(runnable);}

就是创建一个Handler,只创建一次哈，创建Handler用主线程的Looper，这样runnable就post到主线程的Looper里面的MessageQueue中，主线程Looper循环从MessageQueue中取出message,并交给message.target也就是发送message的handler处理