public class MutableLiveData<T> extends LiveData<T> {

    public MutableLiveData(T value) {
        super(value);
    }
    
    MutableLiveData() {
        super();
    }

    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }
}

public abstract class LiveData<T> {
    // 数据锁，通过Synchronized线程同步
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    final Object mDataLock = new Object();
    // LiveData的初始化版本
    // 如果构造方法中没有给值，那么 mVersion 直接使用此值
    // 如果给值，那么 mVersion=START_VERSION+1
    // 见下面构造方法
    static final int START_VERSION = -1;
    // mData的默认值
    // 如果构造方法传值，那么mData使用传入的值
    // 如果没有，则使用此值
    // 见下面构造方法
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    static final Object NOT_SET = new Object();

    // 一个SafeIterableMap，用来保存监听的对象，key是观察者对象，value是观察者和mActive、mVersion构成的一个对象
    // SafeIterableMap是一个可以安全递归的HashMap
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

    // 活跃的Obsever的数量
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    int mActiveCount = 0;
    // 当前LiveData的数据
    private volatile Object mData;
    // 当setData被调用时，我们就设置挂起的数据，实际的数据交换发生在主线程上
    // 咋一看有点迷，看不懂这个注释的意思，但是当我们看完postValue方法后再来看这个就能理解了
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    volatile Object mPendingData = NOT_SET;
    // LiveData版本
    private int mVersion;

    // 是否正在分发数据的flag
    private boolean mDispatchingValue;
    // 是否分发无效的flag
    @SuppressWarnings("FieldCanBeLocal")
    private boolean mDispatchInvalidated;
    // 实现同步锁更新数据的线程，在postValue中被调用，会被发送到主线程中去执行
    private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            Object newValue;
            // 将postValue发过来的数据进行修改
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            // 调用setValue更新数据
            setValue((T) newValue);
        }
    };
    
    public LiveData(T value) {
        mData = value;
        mVersion = START_VERSION + 1;
    }

    public LiveData() {
        mData = NOT_SET;
        mVersion = START_VERSION;
    }
```

## 2.2 LiveData # setValue()
```java
// 通过注解表明只能在主线程使用
@MainThread
protected void setValue(T value) {
    assertMainThread("setValue");
    // 版本增加
    mVersion++;
    // 更新数据
    mData = value;
    // 分发事件
    dispatchingValue(null);
}

protected void postValue(T value) {
    boolean postTask;
    // 对数据更新加锁
    synchronized (mDataLock) {
        // 如果没有设置过值，那么mPendingData == NOT_SET
        // 先将值保存到mPendingData，在通过下面的Runable来更新数据，将mPendingData的值更新到mValue
        postTask = mPendingData == NOT_SET;
        mPendingData = value;
    }
    // postTask为false，就代表数据还没有更新到mValue中去，就不让更新数据
    // 因为postValue和mPostValueRunnable执行之间还有一定的时间间隔
    if (!postTask) {
        return;
    }
    // 通过线程池将数据更新发送到主线程中去更新数据
    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}

// 只许主线程中调用
@MainThread
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
    assertMainThread("observe");
    // Activity和Fragment都实现了Owner接口，所以这个Owner就相当于他们
    // 当他们的状态是DESTROYED时，代表刚创建或者要摧毁了，此时就不需要注册了
    if (owner.getLifecycle().getCurrentState() == DESTROYED) {
        // ignore
        return;
    }
    // 构造一个LifecycleBundleOvserver
    LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
    // 存入mObservers这个map中去
    ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
    // 如果已经存在了，并且他的owner并不是我们调用这个方法时传入的owner，就抛出异常
    if (existing != null && !existing.isAttachedTo(owner)) {
        throw new IllegalArgumentException("Cannot add the same observer"
                + " with different lifecycles");
    }
    // 如果已经存在，就没必要再添加了
    if (existing != null) {
        return;
    }
    // 通过Lifecycle去监听和分发事件
    owner.getLifecycle().addObserver(wrapper);
}

void dispatchingValue(@Nullable ObserverWrapper initiator) {
    // 是否有事件正在被分发
    if (mDispatchingValue) {
        // 分发无效
        mDispatchInvalidated = true;
        return;
    }
    // 由于当前需要分发事件，于是这个flag为true
    mDispatchingValue = true;
    do {
        // 正在分发，所以此flag为false
        mDispatchInvalidated = false;
        // 传入的不为null
        if (initiator != null) {
            // 通过considerNotify去分发
            considerNotify(initiator);
            initiator = null;
        } else {
        // 传入的为null，也就是setValue中的调用
            //遍历mObservers，并且还是能遍历被添加的数据
            for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                    mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                // 通过considerNotify去分发
                considerNotify(iterator.next().getValue());
                // 分发无效就break
                if (mDispatchInvalidated) {
                    break;
                }
            }
        }
    } while (mDispatchInvalidated);
    // 分发结束，设置为false
    mDispatchingValue = false;
}

private void considerNotify(ObserverWrapper observer) {
    // 如果不是active状态了，就不用分发了
    if (!observer.mActive) {
        return;
    }
    // Check latest state b4 dispatch. Maybe it changed state but we didn't get the event yet.
    //
    // we still first check observer.active to keep it as the entrance for events. So even if
    // the observer moved to an active state, if we've not received that event, we better not
    // notify for a more predictable notification order.
    // 如果状态不是STARTED之后的话，那么就更新状态
    if (!observer.shouldBeActive()) {
        observer.activeStateChanged(false);
        return;
    }
    // 如果Observer的Version高于当前Version，那么就没必要去分发
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    // 更新Version
    observer.mLastVersion = mVersion;
    // 事件分发，调用我们实现的Observer的onChanged方法，也就是我们写的代码
    observer.mObserver.onChanged((T) mData);
}

private abstract class ObserverWrapper {
    // Observer
    final Observer<? super T> mObserver;
    // 当前Observer的状态
    boolean mActive;
    // Observer的最新的Version
    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;
        // 如果mActivityCount==0那就意味着没有Observer
        boolean wasInactive = LiveData.this.mActiveCount == 0;
        // 更新mActiveCount
        LiveData.this.mActiveCount += mActive ? 1 : -1;
        if (wasInactive && mActive) {
            // 如果mActive=1，那么就onActive去更新
            onActive();
        }
        if (LiveData.this.mActiveCount == 0 && !mActive) {
            // 如果当前mActiveCount刚刚为0，那么就onInactive
            onInactive();
        }
        // 如果mActive=true，那么就分发
        if (mActive) {
            dispatchingValue(this);
        }
    }
}

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() {
        // 判断当前Lifecycle的状态是不是在STARTED之后
        return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source,
            @NonNull Lifecycle.Event event) {
        // 监听Lifecycle的状态发生变化
        // 如果状态时DESTROYED，
        if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
            // 移除掉这个Observer
            removeObserver(mObserver);
            return;
        }
        // 更新Active
        activeStateChanged(shouldBeActive());
    }

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

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