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
原创不易，求个关注。
微信公众号：一粒尘埃的漫旅
里面有很多想对大家说的话，就像和朋友聊聊天。
写代码，做设计，聊生活，聊工作，聊职场。
我见到的世界是什么样子的？
搜索关注我吧。
公众号与博客的内容不同。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
