一、 一次setValue的更新流程
setValue 源码
@MainThread
protected void setValue(T value) {
assertMainThread("setValue");
mVersion++;
mData = value;
dispatchingValue(null);
}
1、setValue会同步完成Value的更新,只能在主线程中调用
assertMainThread("setValue")
此方法会检查SetValue是不是在主线程中执行,若不是在主线程中,会直接报错
内部具体判断在 DefaultTaskExeutor 类的 isMainThread 中
@Override
public boolean isMainThread() {
return Looper.getMainLooper().getThread() == Thread.currentThread();
}
2、数据分发
dispatchingValue(null); //顾名思义,这个函数就是数据分发类
@SuppressWarnings("WeakerAccess") /* synthetic access */
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;
}
抛去一些并发相关和情况的bool参数判断,实际上具体的分发操作就是
considerNotify(iterator.next().getValue());
函数来完成的
3、通知观察者
@SuppressWarnings("unchecked")
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;
observer.mObserver.onChanged((T) mData);
}
前面的代码都是在判断 观察者的生命周期 和 版本号
最后一句 observer.mObserver.onChanged((T) mData); 就是通知观察者的函数
二、postValue跟setValue
postValue的源码
/**
* Posts a task to a main thread to set the given value. So if you have a following code
* executed in the main thread:
* <pre class="prettyprint">
* liveData.postValue("a");
* liveData.setValue("b");
* </pre>
* The value "b" would be set at first and later the main thread would override it with
* the value "a".
* <p>
* If you called this method multiple times before a main thread executed a posted task, only
* the last value would be dispatched.
*
* @param value The new value
*/
protected void postValue(T value) {
boolean postTask;
synchronized (mDataLock) {
postTask = mPendingData == NOT_SET;
mPendingData = value;
}
if (!postTask) {
return;
}
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
}
1、注解1
liveData.postValue("a");
liveData.setValue("b");
The value "b" would be set at first and later the main thread would override it with
the value "a".
先执行 post a ,后执行 set b。但是 b 会被先复制给 value,然后 a 会把 b覆盖掉。
这是因为 使用 post 方法 去更新value的值, 会调用
ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
,把更新的操作post到 messageQueue里面去,等消息队列去 异步执行。而由于setValue函数是同步执行的,所以先调用postValue反而会在setValue之后更新value。
2、注解2
If you called this method multiple times before a main thread executed a posted task, only the last value would be dispatched.
在主线程执行了第一个已经被post的task(就是mPostValueRunnable) 之前,如果多次调用postValue方法,只有最后一个post的Value会被分发。
也就是多次调用postValue,只有最后一次post会生效。
首先看 mPostValueRunnable 这个runnable干了什么
private final Runnable mPostValueRunnable = new Runnable() {
@SuppressWarnings("unchecked")
@Override
public void run() {
Object newValue;
synchronized (mDataLock) {
newValue = mPendingData;
mPendingData = NOT_SET;
}
setValue((T) newValue);
}
};
最后还是由setValue来完成更新和分发value的操作。
可以看到,newValue其实也就是mPendingData,而我们在每次调用postValue的时候,都会给mPendingData赋值。
所以多次调用postValue之后,mPendingData的值就是最后一次PostValue的值,而mPostValueRunnable此时还在messageQueue里面,还没有来得及执行,mPostValueRunnable里面的newValue最后都会变成最后一次的post的Value。
3、总结
由此来看,postValue跟setValue的区别就是
1、postValue可以在子线程中使用,而setValue不行。
2、postValue最后也还是使用setValue来完成更新和分发操作的,但是会把setValue加入到消息队列中稍后执行,setValue会立即执行。