自己看，如果不對，請指出！

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");
        }
    }
}