MutableLiveData实现消息订阅源码分析

1、创建MutableLiveData对象

MutableLiveData翻译为可变实时数据
创建一个针对List< MonitorTree >列表的对象如下：

  var monitorTree = MutableLiveData<List<MonitorTree>>()

现在看看MutableLiveData的源码：

package androidx.lifecycle;

/**
 * {@link LiveData} which publicly exposes {@link #setValue(T)} and {@link #postValue(T)} method.
 *
 * @param <T> The type of data hold by this instance
 */
@SuppressWarnings("WeakerAccess")
public class MutableLiveData<T> extends LiveData<T> {
    @Override
    public void postValue(T value) {
        super.postValue(value);
    }

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

MutableLiveData继承LiveData类（AAC组件之一），其重载后分别调用了LiveData的postValue和setValue两个关键函数，我们来看看这两个函数在LiveData类中的实现：

	protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }
    
    
	@MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

其中我们看到：
setValue 方法添加了注解 @MainThread， 说明此函数只能在主线程（UI线程）中调用；postValue则允许在后台线程（子线程）中调用。

这也是setValue和postValue最大的区别。

2、添加消息订阅

针对前面的MutableLiveData创建的monitorTree对象实例，添加观察者：

viewModel.monitorTree.observe(mActivity, Observer { data ->
            //TODO 对data（List< MonitorTree >）的数据进行操作
        })

看一下这个viewModel.monitorTree.observe函数做了什么，函数在androidx.lifecycle.LiveData类中，源码如下：

    @MainThread
    public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
        assertMainThread("observe");
        if (owner.getLifecycle().getCurrentState() == DESTROYED) {
            // ignore
            return;
        }
        LifecycleBoundObserver wrapper = new LifecycleBoundObserver(owner, observer);
        ObserverWrapper existing = mObservers.putIfAbsent(observer, wrapper);
        if (existing != null && !existing.isAttachedTo(owner)) {
            throw new IllegalArgumentException("Cannot add the same observer"
                    + " with different lifecycles");
        }
        if (existing != null) {
            return;
        }
        owner.getLifecycle().addObserver(wrapper);
    }

如果：activity生命周期为DESTROYED的直接返回，不往下操作；
否则，创建LifecycleBoundObserver实例，LifecycleBoundObserver 这个类是ObserverWrapper的子类，ObserverWrapper是里面存放了Observer对象，并且封装了activeStateChanged激活状态更新的方法dispatchingValue。

ObserverWrapper将observer观察者放入到LifecycleBoundObserver类的父类ObserverWrapper的mObserver变量中。

然后判断如果这个观察者没有被添加过，那么就put到mObservers对象中。

这时mObservers被赋值了。

同时 owner.getLifecycle().addObserver(wrapper)，这句话是用于对wrapper的生命周期进行观察的。

3、发布消息

发布一个消息有两种方式：

//result是服务器API或者本地数据库查询的数据

//第1种：对应MutableLiveData.postValue ，可以在子线程中发布消息
monitorTree.postValue(result)

//第2种：对应MutableLiveData.setValue()，只能在主线程（UI线程）中发布消息
monitorTree.value = result

3.1、setValue的具体实现

	@MainThread //只能在主线程中调用
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }

先是将本次操作的版本号+1，接着把需要更新的数据存储在mData变量中，最后调用了dispatchingValue(null)方法派发消息。

我们看看dispatchingValue(null)这个方法的实现：

void dispatchingValue(@Nullable ObserverWrapper initiator) {
        if (mDispatchingValue) {
            mDispatchInvalidated = true;
            return;
        }
        mDispatchingValue = true;
        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);
        mDispatchingValue = false;
    }

通过mDispatchingValue标记来判定消息是否被派发了：
如果已派，则设置标记mDispatchInvalidated（派送生效）为true，然后返回结束；
如果未派，则进入do while循环，直到mDispatchInvalidated（派送生效）变为true，才结束循环设置。
do while循环做了最核心的事情，那就是调用considerNotify(ObserverWrapper observer) 考虑通知函数，注意参数observer ，默认是null，意味着还没有添加消息订阅观察者，所以需要进入到mObservers.iteratorWithAdditions() 这个迭代器中去查询，我们需要抓住关键的一个mObservers对象，

private SafeIterableMap<Observer<? super T>, ObserverWrapper> mObservers =
            new SafeIterableMap<>();

SafeIterableMap是一个迭代器对象，我们知道它主要做了两件事情，put及remove这个ObserverWrapper对象，mObservers的赋值操作，前面我们分析了添加消息订阅时，

mObservers已经被赋值了，

所以可以直接用mObservers.iteratorWithAdditions()返回对应的观察者。

接下来我们继续看，considerNotify(ObserverWrapper observer) 考虑通知函数：

private void considerNotify(ObserverWrapper observer) {
        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.
        if (!observer.shouldBeActive()) {
            observer.activeStateChanged(false);
            return;
        }
        if (observer.mLastVersion >= mVersion) {
            return;
        }
        observer.mLastVersion = mVersion;
        //noinspection unchecked
        observer.mObserver.onChanged((T) mData);
    }

首先判断observer是否是活动状态，不是则直接返回，shouldBeActive函数则判断activity的生命周期是否已经执行过onStart及之后的函数，

mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED)

接着，判断版本是否是+1的，不是则直接返回，最后直接调用Observer的onChanged方法，通知添加的观察者。

observer.mObserver.onChanged((T) mData); 这句话就是通知我们观察者，数据发生了变化，回到了我们前面提到过的这个地方，对变化后的数据进行操作：

viewModel.monitorTree.observe(mActivity, Observer { data ->
            //TODO 对data（List< MonitorTree >）的数据进行操作
        })

3.2、postValue的具体实现

protected void postValue(T value) {
        boolean postTask;
        synchronized (mDataLock) {
            postTask = mPendingData == NOT_SET;
            mPendingData = value;
        }
        if (!postTask) {
            return;
        }
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

其核心关键在于这行代码：

 ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

先看看ArchTaskExecutor是个啥：

package androidx.arch.core.executor;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.RestrictTo;

import java.util.concurrent.Executor;

/**
 * A static class that serves as a central point to execute common tasks.
 * <p>
 *
 * @hide This API is not final.
 */
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
public class ArchTaskExecutor extends TaskExecutor {
    private static volatile ArchTaskExecutor sInstance;

    @NonNull
    private TaskExecutor mDelegate;

    @NonNull
    private TaskExecutor mDefaultTaskExecutor;

    @NonNull
    private static final Executor sMainThreadExecutor = new Executor() {
        @Override
        public void execute(Runnable command) {
            getInstance().postToMainThread(command);
        }
    };

    @NonNull
    private static final Executor sIOThreadExecutor = new Executor() {
        @Override
        public void execute(Runnable command) {
            getInstance().executeOnDiskIO(command);
        }
    };

    private ArchTaskExecutor() {
        mDefaultTaskExecutor = new DefaultTaskExecutor();
        mDelegate = mDefaultTaskExecutor;
    }

    /**
     * Returns an instance of the task executor.
     *
     * @return The singleton ArchTaskExecutor.
     */
    @NonNull
    public static ArchTaskExecutor getInstance() {
        if (sInstance != null) {
            return sInstance;
        }
        synchronized (ArchTaskExecutor.class) {
            if (sInstance == null) {
                sInstance = new ArchTaskExecutor();
            }
        }
        return sInstance;
    }
    ...

    @Override
    public void postToMainThread(Runnable runnable) {
        mDelegate.postToMainThread(runnable);
    }
	....
}

可以看到最重要的一个类,位于java.util.concurrent这个包下面的Executor类，就是我们线程及线程池相关的一个接口类，然后通过单例模式创建ArchTaskExecutor对象，通过调用DefaultTaskExecutor类的postToMainThread函数：

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

通过handler创建后i直接传递给主线程（UI线程）。
再来分析一下这个线程参数 mPostValueRunnable ，源码如下：

    private final Runnable mPostValueRunnable = new Runnable() {
        @Override
        public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);
        }
    };

在线程里面调用了setValue函数，回到了setValue调用逻辑里面。

注意这个mPostValueRunnable是与主线程Handler进行关联的，所以可以直接调用setValue函数。线索如下：

mMainHandler = new Handler(Looper.getMainLooper());

4、总结

1、MutableLiveData的postValue可以在子线程中发送消息；
2、MutableLiveData的setValue只能在主线程（UI线程）中发送消息；

相关文章链接：
（四）Android Jetpack 组件之LiveData

原创不易，求个关注。

微信公众号：一粒尘埃的漫旅
里面有很多想对大家说的话，就像和朋友聊聊天。
写代码，做设计，聊生活，聊工作，聊职场。
我见到的世界是什么样子的？
搜索关注我吧。

公众号与博客的内容不同。