初识LiveData

Architecture Components推出1.0稳定版后直接让SupportActivity实现了LifecycleOwner接口，不需要我们先以前一样继承LivecycleActivity了，只要是SupportActivity的子类都是一个LifecycleOwner了

public class SupportActivity extends Activity implements LifecycleOwner {
  //...
}

几个特性

1.如果liveData中已经持有数据，那么 后面添加进来的observer会立即触发onChange(T t)方法，把前面的数据发送出去

public interface Observer<T> {
    void onChanged(@Nullable T t);
}

2.设置数据的如下两种方式

protected void postValue(T value) {//....}
protected void setValue(T value) {//....}

setValue(T value)要求在Ui线程中调用，如果在子线程调用会报错。在子线程需要更新数据的话要调用postValue(T value)，其实这个方法实际上也是调用了setValue方法的

protected void postValue(T value) {
     //...
        ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);
    }

可以看到，在最后他将一个Runnable调度到主线程去执行，mPostValueRunnable如下

public void run() {
            //...
            setValue((T) newValue);
        }

postValue(T value)内部切换线程就一定会增加延迟，所以就印证文档中说的，在主线程执行如下代码，liveData中的数据会先变为b然后变为a

liveData.postValue("a");
liveData.setValue("b");

那么照上面所说，postValue(T value)有一定延迟的话，短时间内一直触发该方法会不会造成任务堆叠呢？我们再来看一看源码

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

看以看出，postTask为假即 mPendingData != NOT_SET时就不会产生新的调度了，NOT_SET就是一个Object，而mPendingData 在初始化时赋值为NOT_SET

//初始化
private static final Object NOT_SET = new Object();
private volatile Object mPendingData = NOT_SET;

在调用postValue后mPendingData 就已经不是NOT_SET了，因此如果一直调用postValue的话是不会产生任务堆叠的。那什么时候postValue才重新有效呢？再来看看被调度的Runnable

public void run() {
            Object newValue;
            synchronized (mDataLock) {
                newValue = mPendingData;
                mPendingData = NOT_SET;
            }
            //noinspection unchecked
            setValue((T) newValue);
        }

mPendingData = NOT_SET;

对，就是这时候postValue(T value)重新有效了，所以循环postValue(T value)的效果是每几个调用只有一个有效，上一个调度完成才会产生下一个，并不会堆叠。