LiveData特性：
1、只有在活跃状态（STARTED,RESUMED）才会收到通知，非活跃状态不会收到更新通知。
2、只有在数据发生变化时才发生更新，且只发送给处于活跃状态的观察者。
3、观察者在首次从非活跃状态变为活跃状态时，会收到更新通知。若第二次从非活跃状态转为活跃状态，则只在值变化时，才会收到通知。
使用注意：
1、尽量放在ViewModel中，不放在Activity或Fragment中，原因：其一、避免Activity/Fragment冗余；其二、在Activity/Fragment配置更改后继续存在。
2、onCreate方法是开始观察LiveData对象的正确着手点。（onCreate方法调用时，Activity/Fragment正处于INITIALIZED状态）
LiveData类图：
从图中可以看出LiveData以一个Map来保存Observer，并且用ObserverWrapper对Observer进行了封装。封装的目的是为了获取“组件状态”，只通知处于活跃状态的观察者。
接下来，以一个介绍LiveData运作过程。包含：一、添加观察者；二、数据发生变化，给观察者发送更新通知；三、生命周期状态发生变化，发送更新通知；四、生命周期结束，撤销观察者。
LiveData执行过程：
通常可能的LiveData用法如下：
searchPageViewModel.hintWordDataList.observe(viewLifecycleOwner, Observer {
adapter.dataList = it
adapter.notifyDataSetChanged()
})一、添加观察者：
上面的observe方法的实现如下：
public void observe(@NonNull LifecycleOwner owner, @NonNull Observer<? super T> observer) {
assertMainThread("observe");
if (owner.getLifecycle().getCurrentState() == DESTROYED) {
// 如果Activity或Fragment处于DESTROYED状态，就不需要设置观察者了
return;
}
//封装Observer和LifecycleOwner到wrapper中，以实现只通知活跃状态的Observer的目的
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);
}在添加LiveData的观察者时，首先将LifecycleOwner和Observer封装到了LifecycleBoundObserver中，此类的作用是：一、提供Observer的状态（即生命感知组件的状态），以实现只通知活跃状态Observer的目的。二、实现了LifecycleEventObserver接口，以观察生命感知组件（Activity或Fragment）的状态变化，在生命感知组件变为活跃状态时，给LiveData的观察者发送一个更新通知。然后，将LifecycleBoundObserver作为“value”，添加到了一个以Observer为“key”的Map中。
二、数据发生变化，给观察者发送更新通知
通常，LiveData会调用setValue方法更新值，其代码如下：
protected void setValue(T value) {
assertMainThread("setValue");
//mVersion表示“值”的版本，每更新一次就加1
mVersion++;
mData = value;
dispatchingValue(null);
}接下来，会调用dispatchingValue方法，以通知观察者值发生变化，注意这里的参数值为null，此方法代码如下：
void dispatchingValue(@Nullable ObserverWrapper initiator) {
if (mDispatchingValue) {
//正在通知观察者，则直接返回，不重复执行相同的操作
mDispatchInvalidated = true;
return;
}
mDispatchingValue = true;
do {
mDispatchInvalidated = false;
if (initiator != null) {
//通知指定观察者initiator，LiveData的值发生变化
considerNotify(initiator);
initiator = null;
} else {
//通知所有观察者，LiveData的值发生变化
for (Iterator<Map.Entry<Observer<? super T>, ObserverWrapper>> iterator =
mObservers.iteratorWithAdditions(); iterator.hasNext(); ) {
considerNotify(iterator.next().getValue());
if (mDispatchInvalidated) {
break;
}
}
}
} while (mDispatchInvalidated);
mDispatchingValue = false;
}此方法的形参为initiator，若initiator不为null，则只对initiator指定的观察者发送更新通知；若为null，则对所有注册的观察者都发送更新通知。在此会调用considerNotify发送更新通知，此方法代码如下：
private void considerNotify(ObserverWrapper observer) {
if (!observer.mActive) {
return;
}
// 检查是否处于活跃状态（STARTED或RESUMED）
if (!observer.shouldBeActive()) {
observer.activeStateChanged(false);
return;
}
// 检查是否处理过LiveData的最新值
if (observer.mLastVersion >= mVersion) {
return;
}
// 未处理过LiveData的最新值，进行处理：
// 更新mLastVersion并调用Observer的onChanged方法
observer.mLastVersion = mVersion;
observer.mObserver.onChanged((T) mData);
}三、生命周期状态发生变化，发送更新通知
前面提过的LifecycleBoundObserver会实现LifecycleEventObserver接口，以观察生命感知组件的状态。此类代码如下：
class LifecycleBoundObserver extends ObserverWrapper implements LifecycleEventObserver {
@NonNull
final LifecycleOwner mOwner;
LifecycleBoundObserver(@NonNull LifecycleOwner owner, Observer<? super T> observer) {
super(observer);
mOwner = owner;
}
//检查Lifecycle（Activity/Fragment）是否处于活跃状态
@Override
boolean shouldBeActive() {
return mOwner.getLifecycle().getCurrentState().isAtLeast(STARTED);
}
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
//获取Lifecycle的状态
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
//通知观察者Observer 状态发生变化
// 若状态为STARTED或RESUMED,则shouldBeActive()为true
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}
......
}在生命感知组件的状态变化时，会调用onStateChanged方法，在此方法中，会检查是否处于活跃状态，若处于活跃状态，会调用activeStateChanged通知观察者Observer，状态发生变化，此方法代码如下：
void activeStateChanged(boolean newActive) {
//若处于活跃状态，newActive为true
if (newActive == mActive) {
return;
}
// immediately set active state, so we'd never dispatch anything to inactive
// owner
mActive = newActive;
// 告知LiveData,使mActiveCount值加1或减1
// mActiveCount表示处于活跃状态的观察者的数量
changeActiveCounter(mActive ? 1 : -1);
if (mActive) {
//给当前观察者发送更新通知
//观察者不一定会更新，由观察者的mLastVersion与LiveData的mVersion决定
dispatchingValue(this);
}
}四、生命周期结束，撤销观察者
当Activity/Fragment处于DESTROYED状态时，LifecycleBoundObserver会收到通知，并撤销LiveData的观察者，代码如下：
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
//获取Lifecycle的状态
Lifecycle.State currentState = mOwner.getLifecycle().getCurrentState();
if (currentState == DESTROYED) {
//撤销LiveData的观察者
removeObserver(mObserver);
return;
}
Lifecycle.State prevState = null;
while (prevState != currentState) {
prevState = currentState;
//通知观察者Observer 状态发生变化
// 若状态为STARTED或RESUMED,则shouldBeActive()为true
activeStateChanged(shouldBeActive());
currentState = mOwner.getLifecycle().getCurrentState();
}
}此方法会调用removeObserver方法，代码如下：
public void removeObserver(@NonNull final Observer<? super T> observer) {
assertMainThread("removeObserver");
//从LiveData的Map中移除观察者
ObserverWrapper removed = mObservers.remove(observer);
if (removed == null) {
return;
}
//最后一次通知观察者，其被移除
removed.detachObserver();
removed.activeStateChanged(false);
}在此方法中，会调用detachObserver方法告知观察者，其被移除，以使观察者做一些移除后的操作，代码如下：
void detachObserver() {
mOwner.getLifecycle().removeObserver(this);
}
这里，在观察者被移除之后，也就不需要观察生命感知组件（Activity或Fragment）的状态变化了，所以要移除之前对生命感知组件添加的观察者。
至此，LiveData的执行过程就分析结束了。