class MainActivity : AppCompatActivity() {
    private val mLiveData = MutableLiveData<String>()
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        val binding = ActivityMainBinding.inflate(LayoutInflater.from(baseContext))
        setContentView(binding.root)
        mLiveData.observe(this, {
            binding.tvContent.text = it
        })
        Thread(BackgroundThread(mLiveData)).start()
    }
    private class BackgroundThread(liveData: MutableLiveData<String>) : Runnable {
        private val mLive = WeakReference(liveData)
        override fun run() {
            mLive.apply {
                get()?.apply {
                    postValue("hello LiveData")
                }
            }
        }
    }
}

@MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        //1,判斷是否在主線程
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        //2，通過owner，observer來構(gòu)建一個LifecycleBoundObserver
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        //3，把observer存放到mObservers中
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        //4，如果existing不為空代表觀察者已經(jīng)存在并且已經(jīng)綁定了生命周期，拋一個Exception來提示                 
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        //5,調(diào)用Lifecycle的addObserver()方法來訂閱生命周期
        owner.getLifecycle().addObserver(wrapper);
    }

protected void postValue(T value) {
        boolean postTask;
        //判斷當前是否正在下發(fā)數(shù)據(jù)
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        //如果正在下發(fā)數(shù)據(jù)則繼續(xù)下發(fā)數(shù)據(jù)
        if (!postTask) {
            return;
        }
        //構(gòu)建Handler并關聯(lián)主線程的Looper，回到主線程執(zhí)行run方法中的邏輯
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //在主線程中調(diào)用setValue來執(zhí)行數(shù)據(jù)下發(fā)邏輯
            //noinspection unchecked
            setValue((T) newValue);
        }
    };

@MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }
void dispatchingValue(@Nullable ObserverWrapper initiator) {
        //1，判斷當前是正在下發(fā)數(shù)據(jù)
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        do {
            mDispatchInvalidated = false;
            //2，如果initiator不為空直接給initiator發(fā)送數(shù)據(jù)更新通知
            if (initiator != null) {
                considerNotify(initiator);
                initiator = null;
            } else {
                /,3，否則遍歷所有observer
                for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
                    /4，發(fā)送數(shù)據(jù)更新通知
                    considerNotify(iterator.next().getValue());
                    if (mDispatchInvalidated) {
                        break;
                    }
                }
            }
        } while (mDispatchInvalidated);
        mDispatchingValue = false;
    }
private void considerNotify(ObserverWrapper observer) {
        5，如果當前observer不是活動狀態(tài)，不下發(fā)數(shù)據(jù)
        if (!observer.mActive) {
            return;
        }
        6，如果當前observer的狀態(tài)至少不是started狀態(tài)（可見狀態(tài)），resumed比started高一個級別（可觸摸狀態(tài)）則不下發(fā)數(shù)據(jù)
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        7，判斷數(shù)據(jù)版本號 如果當前observer的數(shù)據(jù)是最新的 則不下發(fā)數(shù)據(jù)
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        8，記錄最新數(shù)據(jù)版本號
        observer.mLastVersion = mVersion;
        
        9，通知數(shù)據(jù)更新
        observer.mObserver.onChanged((T) mData);
    }
     @Override
        boolean shouldBeActive() {
            判斷當前狀態(tài)是否>=STARTED
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
        }

@Override
        public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
            1，如果當前的狀態(tài)為destroyed就移除observer
            if (mOwner.getLifecycle().getCurrentState() == DESTROYED) {
                removeObserver(mObserver);
                return;
            }
            2，更新狀態(tài)并下發(fā)數(shù)據(jù)
            activeStateChanged(shouldBeActive());
        }
void activeStateChanged(boolean newActive) {
            3，如果新狀態(tài)和當前狀態(tài)一致的話不需要更新
            if (newActive == mActive) {
                return;
            }
            4，記錄新狀態(tài)
            mActive = newActive;
            boolean wasInactive = LiveData.this.mActiveCount == 0;
            LiveData.this.mActiveCount += mActive ? 1 : -1;
            if (wasInactive && mActive) {
                onActive();
            }
            if (LiveData.this.mActiveCount == 0 && !mActive) {
                onInactive();
            }
            5，如果是活動狀態(tài) 下發(fā)數(shù)據(jù)
            if (mActive) {
                dispatchingValue(this);
            }
        }