LiveData的postValue与setValue多次调用问题

1. 使用环境和特点
   setValue()只能在主线程中调用：多次调用每次都会收到
   postValue()可以在任何线程中调用：多次调用，只会收到最后一条更新（当然是在上一条没有发送之前，又收到一条消息时，前一条会被覆盖）

2. 方法分析
   setValue()
   看官方如何介绍这个方法。

 /**
  * Sets the value. If there are active observers, the value will be dispatched to them.
  * <p>
  * This method must be called from the main thread. If you need set a value from a background
  * thread, you can use {@link #postValue(Object)}
  *
  * @param value The new value
  */
 @MainThread
 protected void setValue(T value)

上面的注释已经很清楚了：

这个方法必须在主线程中调用，如果你需要在后台线程中设置value，请移步 #postValue(Object)

  /**
     * Sets the value. If there are active observers, the value will be dispatched to them.
     * <p>
     * This method must be called from the main thread. If you need set a value from a background
     * thread, you can use {@link #postValue(Object)}
     *
     * @param value The new value
     */
    @MainThread
    protected void setValue(T value) {
        assertMainThread("setValue");
        mVersion++;
        mData = value;
        dispatchingValue(null);
    }
        static void assertMainThread(String methodName) {
        if (!ArchTaskExecutor.getInstance().isMainThread()) {
            throw new IllegalStateException("Cannot invoke " + methodName + " on a background"
                    + " thread");
        }
    }

1. 首先调用 assertMainThread() 方法来判断当前线程是否为主线程（这里他通过一个ArchTaskExecutor的单例类来实现），如果不是主线程，直接抛异常
2. 如果是在主线程中调用该方法，mVersion 加1，说明值发生了变化。
3. 再把新的值保存起来。
4. 更新value

postValue
官方对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)

/**
 * 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. 定义一个 postTask 的布尔值，判断是否要更新。
2. 加同步锁，因为可能存在多个子线程同时调用 postValue() 的情况。
3. 通过判断更新的值是否发生变化来对postTask赋值，并且将value赋值给 mPendingData（mPendingData == NOT_SET第一次一定是返回true，之后都是返回false，然后到这个值更新完毕之前的一瞬间会调用mPendingData=NOT_SET，这也是为什么多次调用 postValue()只有最后一个值才有效的原因）。
4. 通过ArchTaskExecutor进行更新，通过方法及参数名字，我们可以猜测这一步干了什么事情：ArchTaskExecutor将一个Runnable对象往主线程里执行，那么mPostValueRunnable执行的环境一定是主线程，接下来我们再看看mPostValueRunnable究竟做了些什么。

   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()

翻译过来就是：

通过任务(Runnable)的方式在主线程中更新数据。
如果同时调用 .postValue(“a”)和.setValue(“b”)，一定是值b被值a覆盖。
如果多次调用 .postValue()，只有最后一个值能够被分发（onChanged()被调用）。

最后
文中有几次出现了ArchTaskExecutor这个东西，这个类其实就是postValue切换至主线程更新的关键它具体的源码实现非常简单，直接是利用了Handler的机制。

	ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
	
......ArchTaskExecutor.........

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

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