scheduleCallback与调度任务

push(taskQueue, newTask);
if (!isHostCallbackScheduled && !isPerformingWork) {
  isHostCallbackScheduled = true;
  //  请求主线程回调
  requestHostCallback(flushWork);
}

// performWorkUntilDeadline 回调次函数时hasTimeRemaining=true，initialTime=currentTime
function flushWork(hasTimeRemaining, initialTime) {
  if (enableProfiling) {
    markSchedulerUnsuspended(initialTime);
  }

  // We'll need a host callback the next time work is scheduled.
  // 当前属于 isPerformingWork 阶段（回调执行阶段），这是允许其他的任务继续请求主线程回调
  isHostCallbackScheduled = false;
  if (isHostTimeoutScheduled) {
    // We scheduled a timeout but it's no longer needed. Cancel it.
    // 如果同步任务队列已经被回调执行了，那么延迟任务队列的延时回调就不需要了
    // 为什么不需要了？因为延时回调 handleTimeout 的功能在 workLoop 中已经被包含了
    // 将延时任务队列中到期的任务放入即时任务队列，视情况请求延时回调或者即时回调，后文详述
    isHostTimeoutScheduled = false;
    cancelHostTimeout();
  }

  // isPerformingWork 表示当前处于同步任务回调执行阶段
  isPerformingWork = true;
  const previousPriorityLevel = currentPriorityLevel;
  try {
    if (enableProfiling) {
      try {
        // 继续调用 workLoop
        return workLoop(hasTimeRemaining, initialTime);
      } catch (error) {
        if (currentTask !== null) {
          const currentTime = getCurrentTime();
          markTaskErrored(currentTask, currentTime);
          currentTask.isQueued = false;
        }
        throw error;
      }
    } else {
      // No catch in prod codepath.
      return workLoop(hasTimeRemaining, initialTime);
    }
  } finally {
    // 执行回调阶段后的清理工作
    currentTask = null;
    currentPriorityLevel = previousPriorityLevel;
    isPerformingWork = false;
    if (enableProfiling) {
      const currentTime = getCurrentTime();
      markSchedulerSuspended(currentTime);
    }
  }
}

function advanceTimers(currentTime) {
  // Check for tasks that are no longer delayed and add them to the queue.
  // 从延时任务中取出最早的任务
  let timer = peek(timerQueue);
  while (timer !== null) {
    // callback 为 null，表示该任务已经被取消了，所以删除之。
    if (timer.callback === null) {
      // Timer was cancelled.
      pop(timerQueue);
    } else if (timer.startTime <= currentTime) {
      // Timer fired. Transfer to the task queue.
      // startTime 已经过了时间了，这说明这个任务已经成为了到期的任务
      // 将之从延时任务队列中取出转移到即时任务队列，并改变其排序的索引
      pop(timerQueue);
      timer.sortIndex = timer.expirationTime;
      push(taskQueue, timer);
      if (enableProfiling) {
        markTaskStart(timer, currentTime);
        timer.isQueued = true;
      }
    } else {
      // Remaining timers are pending.
      // 未到期则直接结束循环，因为整个队列是有序的，后面的一定未到期，不必再判断了
      return;
    }
    // 指针移动到下一个任务
    timer = peek(timerQueue);
  }
}

function workLoop(hasTimeRemaining, initialTime) {
  let currentTime = initialTime;
  // 更新同步任务队列
  advanceTimers(currentTime);
  // 去除最早的即时任务
  currentTask = peek(taskQueue);
  while (
    currentTask !== null &&
    // isSchedulerPaused 表示调度器被中断
    !(enableSchedulerDebugging && isSchedulerPaused)
  ) {
    if (
      currentTask.expirationTime > currentTime &&
      (!hasTimeRemaining || shouldYieldToHost())
    ) {
      // 如果任务并没有过期，或者没有剩余的时间直接终止执行
      // 一般来说这里并不会发生
      // This currentTask hasn't expired, and we've reached the deadline.
      break;
    }
    // 取出当前任务的原始的回调函数
    const callback = currentTask.callback;
    // 这个任务是新任务或者是没有执行完的任务，需要继续执行。
    if (callback !== null) {
      // 将 callback 置空是因为我们现在已经要执行他了
      currentTask.callback = null;
      currentPriorityLevel = currentTask.priorityLevel;
      // didUserCallbackTimeout 恒为 true
      const didUserCallbackTimeout = currentTask.expirationTime <= currentTime;
      markTaskRun(currentTask, currentTime);
      // 执行回调函数，并且获得了回调函数的返回值。
      // 为什么要有返回值？我们要通过这个返回值来判断这个任务到底有没有执行完
      const continuationCallback = callback(didUserCallbackTimeout);
      currentTime = getCurrentTime();
      // 如果回调函数是一个函数，一般会返回回调函数本身，说明任务并没有执行完。只是执行了部分，可能是被中断了。
      if (typeof continuationCallback === 'function') {
        // 把这个回调结果放在callback上。这时任务并没有从队列中移除，只是 callback 改变了。任务的优先级不变。
        currentTask.callback = continuationCallback;
        markTaskYield(currentTask, currentTime);
      } else {
        if (enableProfiling) {
          markTaskCompleted(currentTask, currentTime);
          currentTask.isQueued = false;
        }
        // 回调函数如果不是返回函数说明任务已经执行完了，可以将任务从队列中移除了
        if (currentTask === peek(taskQueue)) {
          pop(taskQueue);
        }
      }
      // 在继续循环之前先更新下即时任务队列。
      advanceTimers(currentTime);
    } else {
      // 已经取消的任务删之。
      pop(taskQueue);
    }
    // 指针移动到队列中的首个任务继续执行。
    currentTask = peek(taskQueue);
  }
  // Return whether there's additional work
  if (currentTask !== null) {
    // 队列的任务并没有执行完，返回 true。
    // 这里会告知任务的执行者，采取措施。
    // 实际上 performWorkUntilDeadline 会通过 port.postMessage 再发出一个消息 
    return true;
  } else {
    // 如果延时任务队列还有任务，通过最早的任务在请求一次延时回调。
    let firstTimer = peek(timerQueue);
    if (firstTimer !== null) {
      requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
    }
    // 任务队列已经执行完，返回 false 表示可以结束本次调度。
    return false;
  }
}

function handleTimeout(currentTime) {
  isHostTimeoutScheduled = false;
  // 更新同步任务队列，此时延时任务队列中的任务应该都没有过期。
  advanceTimers(currentTime);
  // 如果已经请求了主线程回调就没有必要再请求回调了
  if (!isHostCallbackScheduled) {
    // 如果即时任务队列里有任务可以消费了但是没有请求回调，就主动请求一个主线程回调
    if (peek(taskQueue) !== null) {
      isHostCallbackScheduled = true;
      requestHostCallback(flushWork);
    } else {
      // 如果没有即时任务需要去回调执行，就以延时任务队列中最小的 timeout 继续请求延时回调。
      const firstTimer = peek(timerQueue);
      if (firstTimer !== null) {
        requestHostTimeout(handleTimeout, firstTimer.startTime - currentTime);
      }
    }
  }
}