自己看，如果不对，请指出！

package androidx.lifecycle;

import static androidx.lifecycle.Lifecycle.State.DESTROYED;
import static androidx.lifecycle.Lifecycle.State.STARTED;

import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.arch.core.executor.ArchTaskExecutor;
import androidx.arch.core.internal.SafeIterableMap;

import java.util.Iterator;
import java.util.Map;

public abstract class LiveData<T> {
    
    // 用于synchronized同步处理的数据对象
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    final Object mDataLock = new Object();
    
    // 当前持有数据的版本号，默认为-1
    static final int START_VERSION = -1;
    
    // 定义当mData没有数据时的默认数据
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    static final Object NOT_SET = new Object();

    // 用于存储全部的Observer对象的安全迭代Map
    // SafeIterableMap一个能在遍历中删除元素的数据结构
    private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

    // 记录有多少个Active状态的Observer
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    int mActiveCount = 0;
   
    // 用于处理Active\InActive状态
    private boolean mChangingActiveState;
    
    // 真实数据
    private volatile Object mData;
    
    // 当setData被调用, 在主线程进行pending数据和实际数据的交换
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    volatile Object mPendingData = NOT_SET;
    
    // 当前持有数据的版本号
    private int mVersion;

    // 记录在遍历通知各ObserverWrapper期间，数据是否发生变化
    private boolean mDispatchingValue;
    
    // 记录判断是否数据分发无效
    @SuppressWarnings("FieldCanBeLocal")
    private boolean mDispatchInvalidated;
    
    // postValue()函数调用的Runnable
    private final Runnable mPostValueRunnable = new Runnable() {
        @SuppressWarnings("unchecked")
        @Override
        public void run() {
            // 定义新的value
            Object newValue;
            // 同步处理
            synchronized (mDataLock) {
                // 新的value设置为mPendingData
                newValue = mPendingData;
                // mPendingData更新为默认数据
                mPendingData = NOT_SET;
            }
            // 调用setValue()
            setValue((T) newValue);
        }
    };

    /**
     * 有参数的构造函数
     *
     * @param value initial value
     */
    public LiveData(T value) {
        // 实际数据设置为参数传递的数据
        mData = value;
        // 当前持有的数据版本号从-1变为0
        mVersion = START_VERSION + 1;
    }

    /**
     * 无参构造函数
     */
    public LiveData() {
        // 实际数据设置为默认数据
        mData = NOT_SET;
        // 当前版本设置为-1
        mVersion = START_VERSION;
    }

    // 实际更新数据的方法，判断是否需要将数据分发到指定的ObserverWrapper
    @SuppressWarnings("unchecked")
    private void considerNotify(ObserverWrapper observer) {
        // 判断指定的observer是否是Active状态，不是则返回
        if (!observer.mActive) {
            return;
        }
        // 再次确认observer的最新状态，因为有可能生命周期实际上已经变化了，但是Active状态还没改变
        if (!observer.shouldBeActive()) {
            // 如果当前的observer不是Active状态，处于InActive状态，则不进行数据分发，并返回
            observer.activeStateChanged(false);
            return;
        }
        // 判断observer所持有的的版本是不是最新版本，如果是最新版本，则返回
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        // 否则observer的版本就是当前最新版本
        observer.mLastVersion = mVersion;
        // observer通知新数据更新
        observer.mObserver.onChanged((T) mData);
    }

    // 将数据通知给observer
    @SuppressWarnings("WeakerAccess") /* synthetic access */
    void dispatchingValue(@Nullable ObserverWrapper initiator) {
        // 如果在遍历OberverWrapper期间，如果数据发生改变，则会重新遍历通知
        if (mDispatchingValue) {
            // 如果数据发生变化，则分发无效
            mDispatchInvalidated = true;
            return;
        }
        // 设置数据发生变化标识为true
        mDispatchingValue = true;
        do {
            // 分发无效标记设为false
            mDispatchInvalidated = false;
            // 如果传入的initiator不是空的，就只通知特定的ObserWrapper即可，如果是空的，就通知所有的
            if (initiator != null) {
                // 进行实际数据分发
                considerNotify(initiator);
                // initiator对象置空
                initiator = null;
            } else {
                // 遍历所有的ObserverWrapper对象
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
                        mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    // 进行实际数据分发
                    considerNotify(iterator.next().getValue());
                    // 如果期间数据发生了变化，则中断for循环数据分发处理
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
            // 如果数据无效标识为true，则do...while进行重新遍历，通知ObserWrapper进行数据分发
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }

    // 注册Observer
    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        // 判断是否是主线程，不是则抛出异常
        assertMainThread("observe");
        // 判断当前的生命周期持有者是销毁状态，则返回
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        // 创建LifecycleBoundObserver对象
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        // 判断传入的Map中是否已经存在observer，如果存在则返回对象，否则添加并返回空
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 如果已经存在于map中，并且owner不同，则抛出异常
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果存在于map中，则返回
        if (existing != null) {
            return;
        }
        // 如果existing为空，map中不存在，则追加，从而实现对LifecycleOwner生命周期的感知
        owner.getLifecycle().addObserver(wrapper);
    }

    // 永久观察，不在乎生命周期，只要数据发生变化，就会通知Observer
    @MainThread
    public void observeForever(@NonNull Observer<? super T> observer) {
        // 判断是否是主线程，不是则抛出异常
        assertMainThread("observeForever");
        // 创建AlwaysActiveObserver对象
        AlwaysActiveObserver wrapper = new AlwaysActiveObserver(observer);
        // 判断传入的Map中是否已经存在observer，如果存在则返回对象，否则添加并返回空
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        // 判断map中存在Observer的类型，如果类型是LifecycleBoundObserver，不是AlwaysActiveObserver，则抛出异常
        if (existing instanceof LiveData.LifecycleBoundObserver) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        // 如果map中存在则返回
        if (existing != null) {
            return;
        }
        // 直接分发数据
        wrapper.activeStateChanged(true);
    }

    // 移除现有的Observer
    @MainThread
    public void removeObserver(@NonNull final Observer<? super T> observer) {
        // 判断是否是主线程
        assertMainThread("removeObserver");
        // 移除observer对象
        ObserverWrapper removed = mObservers.remove(observer);
        // 如果map中不存在则返回
        if (removed == null) {
            return;
        }
        // 通知生命周期持有者移除
        removed.detachObserver();
        // 不在分发数据
        removed.activeStateChanged(false);
    }

    // 移除指定生命周期持有者对应的Observer
    @SuppressWarnings("WeakerAccess")
    @MainThread
    public void removeObservers(@NonNull final LifecycleOwner owner) {
        // 判断是否是主线程
        assertMainThread("removeObservers");
        // 遍历
        for (Map.Entry<Observer<? super T>, ObserverWrapper> entry : mObservers) {
            // 判断是否owner一致
            if (entry.getValue().isAttachedTo(owner)) {
                // 移除
                removeObserver(entry.getKey());
            }
        }
    }

    /**
     * 子线程处理，最终还是通过setValue函数使用主线程进行分发数据
     * 
     * liveData.postValue("a");
     * liveData.setValue("b");
     * "b"会被setValue函数首先设置，随后会在主线程被"a"覆盖
     *
     * 如果在主线程执行post之前，多次调用该函数，那么只有最后一个值会被分发
     */
    protected void postValue(T value) {
        // 创建标识
        boolean postTask;
        // 同步处理
        synchronized (mDataLock) {
            // mPendingData是否是默认值
            postTask = mPendingData == NOT_SET;
            // 将mPendingData设置为传入的value
            mPendingData = value;
        }
        // 如果mPendingData不是默认值，则返回
        if (!postTask) {
            return;
        }
        // 主线程执行mPostValueRunnable
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

    /**
     * 设置数据，并且直接分发
     * 必须主线程调用
     */
    @MainThread
    protected void setValue(T value) {
        // 判断是否在主线程
        assertMainThread("setValue");
        // 当前持有数据版本高号加1
        mVersion++;
        // 实际数据设置为传递的参数
        mData = value;
        // 分发数据，并且参数传递为null，通知所有Observer
        dispatchingValue(null);
    }

    /**
     * 获取当前数据.
     * 如果在子线程调用，有可能获取的并不是最新的数据
     */
    @SuppressWarnings("unchecked")
    @Nullable
    public T getValue() {
        // 创建临时变量，用于返回
        Object data = mData;
        // 当数据不是默认值的情况返回，否则返回空
        if (data != NOT_SET) {
            return (T) data;
        }
        return null;
    }

    // 获取当前数据版本
    int getVersion() {
        return mVersion;
    }

    /**
     * 当观察者数量从0变为1时调用.
     */
    protected void onActive() {

    }

    /**
     * 当观察者数量从1变为0时调用.
     * 并不意味这当前没有Observer了，只是观察者可能不处于STARTED或者RESUMED状态,例如Activity在后台
     * 可以使用hasObservers检查当前是否还有observer
     */
    protected void onInactive() {
        
    }

    /**
     * 判断当前是否还有Observer
     */
    @SuppressWarnings("WeakerAccess")
    public boolean hasObservers() {
        return mObservers.size() > 0;
    }

    /**
     * 判断当前是否还有处于Active状态的Observer
     */
    @SuppressWarnings("WeakerAccess")
    public boolean hasActiveObservers() {
        return mActiveCount > 0;
    }

    // 更新Active状态Observer的数量
    @MainThread
    void changeActiveCounter(int change) {
        // 将之前的数量保存到局部变量中
        int previousActiveCount = mActiveCount;
        // 当前数量追加
        mActiveCount += change;
        // 当前是否处于Active状态，是Active状态则返回
        if (mChangingActiveState) {
            return;
        }
        // 否则设置为true
        mChangingActiveState = true;
        try {
            // 判断新旧数量是否一致
            while (previousActiveCount != mActiveCount) {
                // 之前没有，现在有了
                boolean needToCallActive = previousActiveCount == 0 && mActiveCount > 0;
                // 之前有，现在没有了
                boolean needToCallInactive = previousActiveCount > 0 && mActiveCount == 0;
                // 局部变量和当前保持一致了
                previousActiveCount = mActiveCount;
                if (needToCallActive) {
                    // 代表增加了
                    onActive();
                } else if (needToCallInactive) {
                    // 代表清空了
                    onInactive();
                }
            }
        } finally {
            // 将状态设置为false
            mChangingActiveState = false;
        }
    }

    // 将LifecycleObserver和ObserverWrapper进行关联，当生命周期发生改变，通知ObserverWrapper进行更新
    class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
        
        // 生命周期持有者对象
        @NonNull
        final LifecycleOwner mOwner;

        // 构造函数
        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            // 生命周期持有者赋值
            mOwner = owner;
        }

        // 判断是否处于Active状态
        // DESTROYED,
        // INITIALIZED,
        // CREATED,
        // STARTED,
        // RESUMED;
        // STARTED和RESUMED算是Active
        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

        // 接收生命周期变化的回调
        @Override
        public void onStateChanged(@NonNull LifecycleOwner source,
                @NonNull Lifecycle.Event event) {
            // 获取当前生命周期的状态
            Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
            if (currentState == DESTROYED) {
                // 如果是destoryed则移除观察者，并返回
                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;
        }

        // 移除Observer
        @Override
        void detachObserver() {
            mOwner.getLifecycle().removeObserver(this);
        }
    }

    // 抽象类ObserWrapper，用于LifecycleBoundObserver和AlwaysActiveObserver
    private abstract class ObserverWrapper {
        // 观察者对象
        final Observer<? super T> mObserver;
        // 状态
        boolean mActive;
        // 版本号
        int mLastVersion = START_VERSION;

        // 构造函数
        ObserverWrapper(Observer<? super T> observer) {
            mObserver = observer;
        }

        // 抽象函数，判断生命周期持有者当前状态，给到LifecycleBoundObserver和AlwaysActiveObserver
        abstract boolean shouldBeActive();

        // LifecycleBoundObserver用于判断生命周期持有者
        boolean isAttachedTo(LifecycleOwner owner) {
            return false;
        }

        // LifecycleBoundObserver用于移除Observer
        void detachObserver() {
        }

        // 状态改变
        void activeStateChanged(boolean newActive) {
            // 如果状态一致则返回
            if (newActive == mActive) {
                return;
            }
            // 立即设置活动状态，这样我们就不会向非活动所有者发送任何内容
            mActive = newActive;
            changeActiveCounter(mActive ? 1 : -1);
            if (mActive) {
                // 活动状态，分发数据
                dispatchingValue(this);
            }
        }
    }

    // 无视生命周期的观察者
    private class AlwaysActiveObserver extends ObserverWrapper {

        // 构造函数
        AlwaysActiveObserver(Observer<? super T> observer) {
            super(observer);
        }

        // 无视生命周期，直接返回true
        @Override
        boolean shouldBeActive() {
            return true;
        }
    }

    // 线程判断
    static void assertMainThread(String methodName) {
        if (!ArchTaskExecutor.getInstance().isMainThread()) {
            throw new IllegalStateException("Cannot invoke " + methodName + " on a background"
                    + " thread");
        }
    }
}