首页 > 编程学习 > LiveData

LiveData

发布时间:2022/11/18 9:28:58

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")
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            setValue((T) newValue);
        }
    };

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

  @MainThread
    protected 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<Map.Entry<Observer<? super T>, 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 {
        @NonNull
        final LifecycleOwner mOwner;
        //构造函数
        LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
            super(observer);
            mOwner = owner;
        }

        @Override
        boolean shouldBeActive() {
            return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);    //判断被观察者的最新状态
        }

        //观察了lifecycleOwner的生命周期状态,所以说虽然liveData是被观察者,但是它作为被观察者通样也是一个观察者
        @Override
        public 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();
            }
        }

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

        @Override
        void 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

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

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

Copyright © 2010-2022 dgrt.cn 版权所有 |关于我们| 联系方式