老大react说：schedule，我们今年的小目标是一个亿_2023-02-19

在浏览器的一帧中js的执行时间如下

`requestIdleCallback`是在浏览器重绘重排之后，如果还有空闲就可以执行未完成的任务，所以为了不影响重绘重排，可以在浏览器在`requestIdleCallback`中执行耗性能的计算，但是由于`requestIdleCallback`存在兼容和触发时机不稳定的问题，`scheduler`中采用`MessageChannel`来实现`requestIdleCallback`，如果当前环境不支持`MessageChannel`就采用`setTimeout`。 

在`performUnitOfWork`(`render`阶段的起点)之后会执行render阶段和`commit`阶段，如果在浏览器的一帧中，`cup`的计算还没完成，就会让出js执行权给浏览器，这个判断在`workLoopConcurrent`函数中，`shouldYield`就是用来判断剩余的时间有没有用尽。在源码中每个时间片时5ms，这个值会根据设备的`fps`调整。

function workLoopConcurrent() {
  while (workInProgress !== null && !shouldYield()) {//如果fiber链还没遍历完，没有被暂停或者打断
    performUnitOfWork(workInProgress);//执行render阶段
  }
}

function forceFrameRate(fps) {//计算时间片
  if (fps < 0 || fps > 125) {
    console['error'](
      'forceFrameRate takes a positive int between 0 and 125, ' +
        'forcing frame rates higher than 125 fps is not supported',
    );
    return;
  }
  if (fps > 0) {
    yieldInterval = Math.floor(1000 / fps);
  } else {
    yieldInterval = 5;//时间片默认5ms
  }
}

//deadline = currentTime + yieldInterval，deadline是在performWorkUntilDeadline函数中计算出来的
if (currentTime >= deadline) {
  //...
    return true
}

    在`Scheduler`中有两个函数可以创建具有优先级的任务

function unstable_runWithPriority(priorityLevel, eventHandler) {
  switch (priorityLevel) {//5种优先级
    case ImmediatePriority:
    case UserBlockingPriority:
    case NormalPriority:
    case LowPriority:
    case IdlePriority:
      break;
    default:
      priorityLevel = NormalPriority;
  }

  var previousPriorityLevel = currentPriorityLevel;//保存当前的优先级
  currentPriorityLevel = priorityLevel;//priorityLevel赋值给currentPriorityLevel

  try {
    return eventHandler();//回调函数
  } finally {
    currentPriorityLevel = previousPriorityLevel;//还原之前的优先级
  }
}

    新建`newTask`任务之后，判断`newTask`是否过期，没过期就加入`timerQueue`中，如果此时`taskQueue`中还没有过期任务，`timerQueue`中离过期时间最近的task正好是`newTask`，则设置个定时器，到了过期时间就加入`taskQueue`中。

    当`timerQueue`中有任务，就取出最早过期的任务执行。

function unstable_scheduleCallback(priorityLevel, callback, options) {
  var currentTime = getCurrentTime();

  var startTime;//开始时间
  if (typeof options === 'object' && options !== null) {
    var delay = options.delay;
    if (typeof delay === 'number' && delay > 0) {
      startTime = currentTime + delay;
    } else {
      startTime = currentTime;
    }
  } else {
    startTime = currentTime;
  }

  var timeout;
  switch (priorityLevel) {
    case ImmediatePriority://优先级越高timeout越小
      timeout = IMMEDIATE_PRIORITY_TIMEOUT;//-1
      break;
    case UserBlockingPriority:
      timeout = USER_BLOCKING_PRIORITY_TIMEOUT;//250
      break;
    case IdlePriority:
      timeout = IDLE_PRIORITY_TIMEOUT;
      break;
    case LowPriority:
      timeout = LOW_PRIORITY_TIMEOUT;
      break;
    case NormalPriority:
    default:
      timeout = NORMAL_PRIORITY_TIMEOUT;
      break;
  }

  var expirationTime = startTime + timeout;//优先级越高 过期时间越小

  var newTask = {//新建task
    id: taskIdCounter++,
    callback//回调函数
    priorityLevel,
    startTime,//开始时间
    expirationTime,//过期时间
    sortIndex: -1,
  };
  if (enableProfiling) {
    newTask.isQueued = false;
  }

  if (startTime > currentTime) {//没有过期
    newTask.sortIndex = startTime;
    push(timerQueue, newTask);//加入timerQueue
    //taskQueue中还没有过期任务，timerQueue中离过期时间最近的task正好是newTask
    if (peek(taskQueue) === null && newTask === peek(timerQueue)) {
      if (isHostTimeoutScheduled) {
        cancelHostTimeout();
      } else {
        isHostTimeoutScheduled = true;
      }
      //定时器，到了过期时间就加入taskQueue中
      requestHostTimeout(handleTimeout, startTime - currentTime);
    }
  } else {
    newTask.sortIndex = expirationTime;
    push(taskQueue, newTask);//加入taskQueue
    if (enableProfiling) {
      markTaskStart(newTask, currentTime);
      newTask.isQueued = true;
    }
    if (!isHostCallbackScheduled && !isPerformingWork) {
      isHostCallbackScheduled = true;
      requestHostCallback(flushWork);//执行过期的任务
    }
  }

  return newTask;
}