从源码看 Jetpack（4）-LiveData衍生

耗时任务的执行是放在 mRefreshRunnable 内部，通过两个 AtomicBoolean 变量来标记 compute()的执行状态，并将任务体放在 while 循环内部，在任务过时的时候自动重新执行

	@VisibleForTesting
    final Runnable mRefreshRunnable = new Runnable() {
 @WorkerThread
 @Override
 public void run() {
     boolean computed;
     do {
  computed = false;
  // compute can happen only in 1 thread but no reason to lock others.

  //1. 如果 mComputing 为 false，则将其置为 true。意味着当前没有在执行 compute() 函数，从而使得等式成立，进入 if 内部
  //   从而限制了耗时任务只能同时在一个线程下执行
  //2. 如果 mComputing 为 true ，意味着当前正在执行 compute() 函数，等式不成立，直接跳出 do while 循环，避免阻塞当前线程
  if (mComputing.compareAndSet(false, true)) {
      // as long as it is invalid, keep computing.
      try {
   T value = null;
   //1. 当 mInvalid 为 true 时，则将其置为 false，等式成立，进入 while 内部，开始执行耗时任务
   //2. 当 mInvalid 为 false 时，等式不成立，跳出 while 循环

   //由于将 mInvalid 置为 false 的操作只会出现在这里，所以第二种情况只会出现在进入 while 循环后触发
   while (mInvalid.compareAndSet(true, false)) {
computed = true;
value = compute();
   }
   //如果 computed 为 true，则意味着 compute() 执行完成，且执行过程中没有抛出异常
   //此时就直接向外部回调结果值
   if (computed) {
mLiveData.postValue(value);
   }
      } finally {
   // release compute lock
   //释放状态锁，将当前置为非计算状态
   mComputing.set(false);
      }
  }
  // check invalid after releasing compute lock to avoid the following scenario.
  // Thread A runs compute()
  // Thread A checks invalid, it is false
  // Main thread sets invalid to true
  // Thread B runs, fails to acquire compute lock and skips
  // Thread A releases compute lock
  // We've left invalid in set state. The check below recovers.

  //当 computed 和 mInvalid 均为 true 时，则重新开始一轮循环
  //会出现这种情况，意味着 compute() 函数执行成功，但外部将其置为已过时状态，需要重新执行一次 compute() 函数
     } while (computed && mInvalid.get());
 }
    };

    // invalidation check always happens on the main thread
    @VisibleForTesting
    final Runnable mInvalidationRunnable = new Runnable() {
 @MainThread
 @Override
 public void run() {
     //判断当前外部是否有对 LiveData 进行监听
     boolean isActive = mLiveData.hasActiveObservers();
     //如果 mInvalid 为 false，则将其置为 true，等式成立
     if (mInvalid.compareAndSet(false, true)) {
  //只在当前外部有对 LiveData 进行监听的情况下才触发耗时任务
  if (isActive) {
      mExecutor.execute(mRefreshRunnable);
  }
     }
 }
    };

    
    //将当前的耗时任务置为过时状态
    //当外部有 Observer 对 LiveData 进行监听，则将重新触发执行耗时任务
    public void invalidate() {
 ArchTaskExecutor.getInstance().executeOnMainThread(mInvalidationRunnable);
    }

    //由外部实现耗时任务的具体逻辑
    // TODO https://issuetracker.google.com/issues/112197238
    @SuppressWarnings({"WeakerAccess", "UnknownNullness"})
    @WorkerThread
    protected abstract T compute();