LiveData简单解析

/**
 * 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 //注解1
protected void setValue(T value) {
    assertMainThread("setValue");//注解2
    mVersion++;
    mData = value;
    dispatchingValue(null);//注解3
}

注解1+注解2 = 我们知道了setValue 只能在主线程中运行  ///Nice 脑壳又进了一点知识

/**
 * 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：ArchTaskExecutor调用获取实例方法  然后将任务发送至主线程中/**
 * 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;
}
///私有构造
private ArchTaskExecutor() {
    mDefaultTaskExecutor = new DefaultTaskExecutor();
    mDelegate = mDefaultTaskExecutor;
}

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

@Override
public void postToMainThread(Runnable runnable) {
    if (mMainHandler == null) {
        synchronized (mLock) { 
            if (mMainHandler == null) {
                mMainHandler = createAsync(Looper.getMainLooper());
            }
        }
    }
    //noinspection ConstantConditions
    mMainHandler.post(runnable);///看到MAinHandler 原来是这样跑到主线程去得
}

ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);   
哈哈哈找到了 mPostValueRunnable 是你  那这个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);///注释1
    }
};

go dispatchingValue(null);//注解3
 
 @SuppressWarnings("WeakerAccess") /* synthetic access */
void dispatchingValue(@Nullable ObserverWrapper initiator) {
    if (mDispatchingValue) {///注解1：首先先判断是否是正在发送中
        mDispatchInvalidated = true;///是的话 return
        return;
    }
    mDispatchingValue = true;///标记为发送中
    ///一个do whild循环 :dowhile  至少执行一次
    do {
        mDispatchInvalidated = false;
        if (initiator != null) {///判断该initiator  是否为空 setValue传进来的都是null
            considerNotify(initiator);///只更改当前ObserverWrapper 
            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;///取消标记为分发中的状态
}

private void considerNotify(ObserverWrapper observer) {
    if (!observer.mActive) {///如果不是活越状态 就不继续发送事件   注解1
        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);
        //传入false  内部会进行判断是否需要再次判断是否执行onActive方法和onInactive方法回调。如果判断条件都满足会调用Observer的onChanged方法
        return;
    }
    if (observer.mLastVersion >= mVersion) {
        return;
    }
    observer.mLastVersion = mVersion;
    //noinspection unchecked
    observer.mObserver.onChanged((T) mData);
    ///哦豁 实现了数据通知
}

 * If the specified key is not already associated
 * with a value, associates it with the given value.
 *
 * @param key key with which the specified value is to be associated
 * @param v   value to be associated with the specified key
 * @return the previous value associated with the specified key,
 * or {@code null} if there was no mapping for the key
 */
public V putIfAbsent(@NonNull K key, @NonNull V v) {
    
    Entry<K, V> entry = get(key);///具体实现看下面get方法
    if (entry != null) {///如果当前节点不为空 就返回value
        return entry.mValue;
    }
    put(key, v);///否则存储 返回null
    return null;  
}


////get方法
protected Entry<K, V> get(K k) {
    Entry<K, V> currentNode = mStart;///Entry 是一个双向链表
    while (currentNode != null) {///一个whild 循环
        if (currentNode.mKey.equals(k)) {
            ///判断当前链表的k 是否和当前k相等  相等则跳出循环
            break;
        }
        currentNode = currentNode.mNext;///否则等于下个next 
    }
    return currentNode;///最后 如果当前链表中有k则返回当前节点  否则返回的是null 
}