React源码04 - Fiber Scheduler (调度器)

创建更新之后,找到 Root 然后进入调度,同步和异步操作完全不同,实现更新分片的性能优化。

主流的浏览器刷新频率为 60Hz,即每(1000ms / 60Hz)16.6ms 浏览器刷新一次。JS可以操作 DOM,JS线程GUI渲染线程 是互斥的。所以 **JS脚本执行 **和 **浏览器布局、绘制 **不能同时执行。
在每16.6ms时间内,需要完成如下工作:

JS脚本执行 -----  样式布局 ----- 样式绘制

既然以浏览器是否有剩余时间作为任务中断的标准,那么我们需要一种机制,当浏览器在每一帧 16.6ms 中执行完自己的 GUI 渲染线程后,还有剩余时间的话能通知我们执行 react 的异步更新任务,react 执行时会自己计时,如果时间到了,而 react 依然没有执行完,则会挂起自己,并把控制权还给浏览器,以便浏览器执行更高优先级的任务。然后 react 在下次浏览器空闲时恢复执行。而如果是同步任务,则不会中断,会一直占用浏览器直到页面渲染完毕。

其实部分浏览器已经实现了这个API,这就是 requestIdleCallback(字面意思:请求空闲回调)。但是由于以下因素,React 放弃使用:

  • 浏览器兼容性
  • 触发频率不稳定,受很多因素影响。比如当我们的浏览器切换tab后,之前tab注册的 requestIdleCallback 触发的频率会变得很低。

React 实现了功能更完备的 requestIdleCallback polyfill(使用window.requestAnimationFrame() 和 JavaScript 任务队列进行模拟),这就是 Scheduler,除了在空闲时触发回调的功能外,Scheduler 还提供了多种调度优先级供任务设置。

当 Scheduler 将任务交给 Reconciler 后,Reconciler 会为变化的虚拟 DOM 打上代表增/删/更新的标记,类似这样:

// 这种二进制存储数据:
// 设置:集合 | 目标
// 查询:集合 & 目标
// 取消:集合 & ~目标

export const Placement = /*             */ 0b0000000000010;
export const Update = /*                */ 0b0000000000100;
export const PlacementAndUpdate = /*    */ 0b0000000000110;
export const Deletion = /*              */ 0b0000000001000;

整个 Scheduler 与 Reconciler 的工作都在内存中进行。只有当所有组件都完成 Reconciler 的工作后,才会统一交给 Renderer。

Renderer 根据 Reconciler 为虚拟 DOM 打的标记,同步执行对应的 DOM 操作。


image.png

其中红框中的步骤随时可能由于以下原因被中断:

  • 有其他更高优任务需要先更新
  • 当前帧没有剩余时间

由于红框中的工作都在内存中进行,不会更新页面上的DOM,即使反复中断用户也不会看见更新不完全的DOM。
因此可以说 Scheduler 和 Reconciler 是和平台无关的,而和平台相关的是 Renderer。

大致更新调度的流程:

  • 首先通过 ReactDOM.render/setState/forceUpdate 产生更新。
  • 找到产生更新的节点所对应的 FiberRoot,将其加入到调度器中(多次调用 ReactDOM.render 就会有多个 root)。
  • 根据 expirationTime 判断是同步更新,还是异步更新。具体就是在上一篇提到的,在 computeExpirationForFiber() 计算过期时间时,根据 fiber.mode & ConcurrentMode 模式是否开启,来计算同步的过期时间,和异步的过期时间,也就是 同步更新任务异步更新任务 。同步更新任务没有 deadline(用于 react 执行的分片时间),会立即执行,不会被中断。而异步更新任务有 deadline,需要等待调度,并可能会中断。在此过程中,同步任务和异步任务最终会汇聚到一起,根据是否有 deadline,会进入同步循环条件或异步循环条件,而这个循环就是指遍历整棵 Fiber 树的每个节点进行更新的操作。同步任务遍历完更新完就完了,而异步任务在更新节点时会受到分片调度的控制。
  • 异步更新任务被加入到 Scheduler 的 callbackList 中等待调度。调度时,会检查是否有任务已经过期(expirationTime),会先把所有已经超时的任务执行掉,直到遇到非超时的任务时,如果当前时间分片 deadline 还没到点,则继续执行,如果已经到点了,则控制权交给浏览器。
  • 采用了 deadline 分片保证异步更新任务不会阻塞浏览器 GUI 的渲染、如动画等能在 30FPS 以上。

TODO:Scheduler 图,可能要自己手绘

2. scheduleWork

在上一篇 “React 中的更新” 提到,ReactDOM.render/setState/forceUpdate 最终都会进入 scheduleWork 即调度工作。

  • 找到更新所对应的 FiberRoot 节点。
  • 如果符合条件则重置 stack
  • 如果符合条件就请求工作调度

TODO: Fiber 树图
**
点击 button,是 List 组件实例调用了 setState,创建 update 后开始调度时,是将 List 所在的 RootFiber 这个 fiber 根节点加入到调度队列中(而并不是直接把 List Fiber 节点加入调度中),正如每次更新时也是从 RootFiber 开始更新。

一些全局变量:

  • isWorking: 用来标志是否当前有更新正在进行,不区分阶段,包含了 commit 和 render 阶段
  • isCommitting: 是否处于 commit 阶段

React在16版本之后处理任务分为两个阶段

  • render 阶段: 判断哪些变更需要被处理成 DOM,也就是比较上一次渲染的结果和新的更新,打标记。
  • commit 阶段: 处理从 js 对象到 DOM 的更新,不会被打断,并且会调用 componentDidMount 和 componentDidUpdate 这些生命周期方法。
function scheduleWork(fiber: Fiber, expirationTime: ExpirationTime) {
  const root = scheduleWorkToRoot(fiber, expirationTime);
  if (root === null) {
    return;
  }

  // 异步任务由于时间片不够被中断,执行权了交给浏览器,
  // 此时产生了更新任务,其优先级更高,则会打断老的任务。
  if (
    !isWorking &&
    nextRenderExpirationTime !== NoWork &&
    expirationTime < nextRenderExpirationTime
  ) {
    // This is an interruption. (Used for performance tracking.)
    interruptedBy = fiber; // 给开发工具用的,用来展示被哪个节点打断了异步任务
    resetStack(); // 重置之前的中断的任务已经产生的部分节点更新
  }
  // 暂时先忽略
  markPendingPriorityLevel(root, expirationTime);
  
  // 没有正在进行的工作,或者是上一次render阶段已经结束(更新结束),已经到了commit阶段,
  // 那么可以继续请求一次调度工作。
  if (
    // If we're in the render phase, we don't need to schedule this root
    // for an update, because we'll do it before we exit...
    !isWorking ||
    isCommitting ||
    // ...unless this is a different root than the one we're rendering.
    nextRoot !== root // 单个FiberRoot入口时nextRoot永远等于root,所以基本不需要考虑这个条件,因为基本都是单入口应用
  ) {
    const rootExpirationTime = root.expirationTime;
    requestWork(root, rootExpirationTime); // 请看下一节
  }
  
  // 检测死循环更新
  if (nestedUpdateCount > NESTED_UPDATE_LIMIT) {
    // Reset this back to zero so subsequent updates don't throw.
    nestedUpdateCount = 0;
    invariant(
      false,
      'Maximum update depth exceeded. This can happen when a ' +
      'component repeatedly calls setState inside ' +
      'componentWillUpdate or componentDidUpdate. React limits ' +
      'the number of nested updates to prevent infinite loops.',
    );
  }
}

function resetStack() {
  // 用于记录render阶段Fiber树遍历过程中下一个需要执行的节点,
  // 不为null说明之前存在更新任务,只是时间片不够了,被中断了
  // 于是就要向上遍历父节点,将已经更新了的状态回退到更新之前,
  // 回退是为了避免状态混乱,不能把搞了一半的摊子直接丢给新的更新任务,
  // 因为新的高优先级任务也要从根节点RootFiber开始更新。
  if (nextUnitOfWork !== null) {
    let interruptedWork = nextUnitOfWork.return;
    while (interruptedWork !== null) {
      unwindInterruptedWork(interruptedWork);
      interruptedWork = interruptedWork.return;
    }
  }

  if (__DEV__) {
    ReactStrictModeWarnings.discardPendingWarnings();
    checkThatStackIsEmpty();
  }

  // 回退一些全局变量
  nextRoot = null;
  nextRenderExpirationTime = NoWork;
  nextLatestAbsoluteTimeoutMs = -1;
  nextRenderDidError = false;
  nextUnitOfWork = null;
}

scheduleWorkToRoot() 根据传入的 Fiber 节点,找到对应的 FiberRoot(也就是最初调用 ReactDOM.render 时创建的 FiberRoot)。对于 ReactDOM.render 产生的调用 scheduleWork() ,其传入的是 RootFiber 节点, RootFiber.stateNode 就找到了 FiberRoot;而 setState/forceUpdate 传入的是自身组件所对应的 Fiber 子节点,会复杂一些:

function scheduleWorkToRoot(fiber: Fiber, expirationTime): FiberRoot | null {
  // 记录调度时间,
  recordScheduleUpdate();

  // 如果尚未更新过,没有存储过期时间,或者最新计算出的过期时间更短,意味着优先级更高,
  // 那么就更新目标Fiber上的过期时间 (即产生更新的那个Fiber,如刚才的List组件对应的Fiber)
  // Update the source fiber's expiration time
  if (
    fiber.expirationTime === NoWork ||
    fiber.expirationTime > expirationTime
  ) {
    fiber.expirationTime = expirationTime;
  }
  let alternate = fiber.alternate;
  // 同理如果alternate fiber(之前说过的双缓存、双buff机制)存在,也要尝试更新过期时间
  if (
    alternate !== null &&
    (alternate.expirationTime === NoWork ||
      alternate.expirationTime > expirationTime)
  ) {
    alternate.expirationTime = expirationTime;
  }
  
  
  // Walk the parent path to the root and update the child expiration time.
  let node = fiber.return; // fiber.return指向的就是父fiber节点。
  let root = null;
  // 只有RootFiber.return会是null,说明传入的Fiber就是RootFiber,其tag就是3,也就是HostRoot 
  if (node === null && fiber.tag === HostRoot) { 
    root = fiber.stateNode; // 找到了 FiberRoot
  } else {
    // 向上遍历,寻找FiberRoot
    while (node !== null) {
      alternate = node.alternate;
      if (
        node.childExpirationTime === NoWork ||
        node.childExpirationTime > expirationTime
      ) {
        // childExpirationTime: 父节点记录了子树中优先级最高的过期时间,即最先的过期时间
        // 如果当前传入节点的过期时间优先级更高,则更新父节点的childExpirationTime,
        // 同理还要更新父节点的alternate节点。
        node.childExpirationTime = expirationTime;
        if (
          alternate !== null &&
          (alternate.childExpirationTime === NoWork ||
            alternate.childExpirationTime > expirationTime)
        ) {
          alternate.childExpirationTime = expirationTime;
        }
      // node.childExpirationTime不需要更新,node.alternate.childExpirationTime也要尝试更新
      } else if (
        alternate !== null &&
        (alternate.childExpirationTime === NoWork ||
          alternate.childExpirationTime > expirationTime)
      ) {
        alternate.childExpirationTime = expirationTime;
      }
      // 找到了 FiberRoot 就跳出
      if (node.return === null && node.tag === HostRoot) {
        root = node.stateNode;
        break;
      }
      // 没找到则指针上溯,继续下次while循环
      node = node.return;
    }
  }

  // 提醒当前传入的fiber没有找到FiberRoot节点
  if (root === null) {
    if (__DEV__ && fiber.tag === ClassComponent) {
      warnAboutUpdateOnUnmounted(fiber);
    }
    return null;
  }

  // 跟踪应用更新的相关代码,精力和水平有限,汪洋大海不再深究。
  if (enableSchedulerTracing) {
    const interactions = __interactionsRef.current;
    if (interactions.size > 0) {
      const pendingInteractionMap = root.pendingInteractionMap;
      const pendingInteractions = pendingInteractionMap.get(expirationTime);
      if (pendingInteractions != null) {
        interactions.forEach(interaction => {
          if (!pendingInteractions.has(interaction)) {
            // Update the pending async work count for previously unscheduled interaction.
            interaction.__count++;
          }

          pendingInteractions.add(interaction);
        });
      } else {
        pendingInteractionMap.set(expirationTime, new Set(interactions));

        // Update the pending async work count for the current interactions.
        interactions.forEach(interaction => {
          interaction.__count++;
        });
      }

      const subscriber = __subscriberRef.current;
      if (subscriber !== null) {
        const threadID = computeThreadID(
          expirationTime,
          root.interactionThreadID,
        );
        subscriber.onWorkScheduled(interactions, threadID);
      }
    }
  }

  return root;
}

3. requestWork

  • 加入到 root 调度队列
  • 判断是否批量更新
  • 根据 expirationTime 判断调度类型

requestWork:

// requestWork is called by the scheduler whenever a root receives an update.
// It's up to the renderer to call renderRoot at some point in the future.
function requestWork(root: FiberRoot, expirationTime: ExpirationTime) {
  addRootToSchedule(root, expirationTime);
  if (isRendering) {
    // Prevent reentrancy. Remaining work will be scheduled at the end of
    // the currently rendering batch.
    return;
  }
    // 关于批处理,下一小节来探讨
  if (isBatchingUpdates) {
    // Flush work at the end of the batch.
    if (isUnbatchingUpdates) {
      // ...unless we're inside unbatchedUpdates, in which case we should
      // flush it now.
      nextFlushedRoot = root;
      nextFlushedExpirationTime = Sync;
      performWorkOnRoot(root, Sync, true);
    }
    return;
  }

  // TODO: Get rid of Sync and use current time?
  if (expirationTime === Sync) { 
    // 同步调用js代码直到结束为止,不会被打断。
    performSyncWork();
  } else { 
    // 否则进行异步调度,进入到了独立的scheduler包中, 即react的requestIdleCallback polyfill
    // 等待有在deadline时间片内才能得到执行,deadline到点后则控制权交给浏览器,等待下一个时间片。
    scheduleCallbackWithExpirationTime(root, expirationTime);
  }
}

addRootToSchedule:

  • 检查 root 是否已参与调度,没有则加入到 root 调度队列,实际就是单向链表添加节点的操作。当然绝大多数时候,我们的应用只有一个 root。
  • 如果 root 已经参与调度,但可能需要提升优先级,使用 expirationTime 保存最高优先级的任务。
function addRootToSchedule(root: FiberRoot, expirationTime: ExpirationTime) {
  // Add the root to the schedule.
  // Check if this root is already part of the schedule.
  if (root.nextScheduledRoot === null) {
    // This root is not already scheduled. Add it.
    root.expirationTime = expirationTime;
    if (lastScheduledRoot === null) {
      firstScheduledRoot = lastScheduledRoot = root;
      root.nextScheduledRoot = root;
    } else {
      lastScheduledRoot.nextScheduledRoot = root;
      lastScheduledRoot = root;
      lastScheduledRoot.nextScheduledRoot = firstScheduledRoot;
    }
  } else {
    // This root is already scheduled, but its priority may have increased.
    const remainingExpirationTime = root.expirationTime;
    if (
      remainingExpirationTime === NoWork ||
      expirationTime < remainingExpirationTime
    ) {
      // Update the priority.
      root.expirationTime = expirationTime;
    }
  }
}

4. batchUpdates

顾名思义,批量更新,可以避免短期内的多次渲染,攒为一次性更新。

在后面提供的 demo 中的 handleClick 中有三种方式调用 this.countNumber()
**
第1种:
批量更新,会打印 0 0 0,然后按钮文本显示为3。每次 setState 虽然都会经过 enqueueUpdate (创建update 并加入队列)-> scheduleWork(寻找对应的 FiberRoot 节点)-> requestWork (把 FiberRoot 加入到调度队列),可惜上下文变量 isBatchingUpdates 在外部某个地方被标记为了 true ,因此本次 setState 一路走来,尚未到达接下来的 performSyncWork 或者 scheduleCakkbackWithExpirationTime 就开始一路 return 出栈:

image

isBatchingUpdates 变量在早前的调用栈中(我们为 onClick 绑定的事件处理函数会被 react 包裹多层),被标记为了 true ,然后 fn(a, b) 内部经过了3次 setState 系列操作,然后 finally 中 isBatchingUpdates 恢复为之前的 false,此时执行同步更新工作 performSyncWork

image

第2种:
handleClick 中使用 setTimeoutthis.countNumber 包裹了一层 setTimeout(() => { this.countNumber()}, 0) ,同样要调用 handleClick 也是先经过 interactiveUpdates$1 上下文,也会执行 setTimeout ,然后 fn(a, b) 就执行完了,因为最终是浏览器来调用 setTimeout 的回调 然后执行里面的 this.countNumber ,而对于 interactiveUpdates$1 来说继续把自己的 performSyncWork 执行完,就算结束了。显然不管 performSyncWork 做了什么同步更新,我们的 setState 目前为止都还没得到执行。然后等到 setTimeout 的回调函数等到空闲被执行的时候,才会执行 setState ,此时没有了批量更新之上下文,所以每个 setState 都会单独执行一遍 requestWork 中的 performSyncWork 直到渲染结束,且不会被打断,3次 setState 就会整个更新渲染 3 遍(这样性能不好,所以一般不会这样写 react)。
什么叫不会被打断的同步更新渲染?看一下 demo 中的输出,每次都同步打印出了最新的 button dom 的 innerText

第3种:
已经可以猜到,无非就是因为使用 setTimeout 而“错过了”第一次的批量更新上下文,那等到 setTimeout 的回调执行的时候,专门再创建一个批量更新上下文即可:

image.png

**
所以,setState 是同步还是异步?
**
setState 方法本身是被同步调用,但并不代表 react 的 state 就会被立马同步地更新,而是要根据当前执行上下文来判断。
如果处于批量更新的情况下,state 不会立马被更新,而是批量更新。
如果非批量更新的情况下,那么就“有可能”是立马同步更新的。为什么不是“一定”?因为如果 React 开启了 Concurrent Mode,非批量更新会进入之前介绍过的异步调度中(时间分片)。

批量更新演示 demo:

import React from 'react'
import { unstable_batchedUpdates as batchedUpdates } from 'react-dom'

export default class BatchedDemo extends React.Component {
  state = {
    number: 0,
  }

  handleClick = () => {
    // 事件处理函数自带batchedUpdates
    // this.countNumber()

    // setTimeout中没有batchedUpdates
    setTimeout(() => {
      this.countNumber()
    }, 0)

    // 主动batchedUpdates
    // setTimeout(() => {
    //   batchedUpdates(() => this.countNumber())
    // }, 0)
  }

  countNumber() {
    const button = document.getElementById('myButton')
    const num = this.state.number
    this.setState({
      number: num + 1,
    })
    console.log(this.state.number)
    console.log(button.innerText)
    this.setState({
      number: num + 2,
    })
    console.log(this.state.number)
    console.log(button.innerText)
    this.setState({
      number: num + 3,
    })
    console.log(this.state.number)
    console.log(button.innerText)
  }

  render() {
    return 
  }
}

5. Scheduler 调度器

  • 维护时间片
  • 模拟 requestIdleCallback
  • 调度列表和超时判断

如果1秒30帧,那么需要是平均的30帧,而不是前0.5秒1帧,后0.5秒29帧,这样也会感觉卡顿的。
Scheduler 目的就是保证 React 执行更新的时间,在浏览器的每一帧里不超过一定值。
不要过多占用浏览器用来渲染动画或者响应用户输入的处理时间。

image

image

**
继续之前的源码,requestWork 的最后,如果不是同步的更新任务,那么就要参与 Scheduler 时间分片调度了:

  // TODO: Get rid of Sync and use current time?
  if (expirationTime === Sync) {
    performSyncWork();
  } else {
    scheduleCallbackWithExpirationTime(root, expirationTime);
  }

scheduleCallbackWithExpirationTime:

function scheduleCallbackWithExpirationTime(
  root: FiberRoot,
  expirationTime: ExpirationTime,
) {
  
  // 如果已经有在调度的任务,那么调度操作本身就是在循环遍历任务,等待即可。
  if (callbackExpirationTime !== NoWork) {
    // A callback is already scheduled. Check its expiration time (timeout).
    // 因此,如果传入的任务比已经在调度的任务优先级低,则返回
    if (expirationTime > callbackExpirationTime) {
      // Existing callback has sufficient timeout. Exit.
      return;
    } else {
      // 但是!如果传入的任务优先级更高,则要打断已经在调度的任务
      if (callbackID !== null) {
        // Existing callback has insufficient timeout. Cancel and schedule a
        // new one.
        cancelDeferredCallback(callbackID);
      }
    }
    // The request callback timer is already running. Don't start a new one.
  } else {
    startRequestCallbackTimer(); // 涉及到开发工具和polyfill,略过
  }
    
  // 如果是取消了老的调度任务,或者是尚未有调度任务,则接下来会安排调度
  callbackExpirationTime = expirationTime;
  // 计算出任务的timeout,也就是距离此刻还有多久过期
  const currentMs = now() - originalStartTimeMs; // originalStartTimeMs 代表react应用最初被加载的那一刻
  const expirationTimeMs = expirationTimeToMs(expirationTime);
  const timeout = expirationTimeMs - currentMs;
  // 类似于 setTimeout 返回的 ID,可以用来延期回调
  callbackID = scheduleDeferredCallback(performAsyncWork, {timeout});
}

6. unstable_scheduleCallback

前面都还在 packages/react-reconciler/ReactFiberScheduler.js 中,下面就要跟着刚才的 **scheduleDeferredCallback **辗转进入到单独的 packages/scheduler 包中:

  • 根据不同优先级等级计算不同的 callbackNode 上的过期时间。
  • 存储以过期时间为优先级的环形链表,用时可借助首节点 firstCallbackNode 可对链表进行遍历读取。
  • firstCallbackNode 变了后要调用 ensureHostCallbackIsScheduled 重新遍历链表进行调度。
image

unstable_scheduleCallback:

function unstable_scheduleCallback(callback, deprecated_options) {
  var startTime =
    currentEventStartTime !== -1 ? currentEventStartTime : getCurrentTime();

  var expirationTime;
  if (
    typeof deprecated_options === 'object' &&
    deprecated_options !== null &&
    typeof deprecated_options.timeout === 'number'
  ) {
    // FIXME: Remove this branch once we lift expiration times out of React.
    expirationTime = startTime + deprecated_options.timeout;
  } else {
    switch (currentPriorityLevel) {
      case ImmediatePriority:
        expirationTime = startTime + IMMEDIATE_PRIORITY_TIMEOUT;
        break;
      case UserBlockingPriority:
        expirationTime = startTime + USER_BLOCKING_PRIORITY;
        break;
      case IdlePriority:
        expirationTime = startTime + IDLE_PRIORITY;
        break;
      case NormalPriority:
      default:
        expirationTime = startTime + NORMAL_PRIORITY_TIMEOUT;
    }
  }

  var newNode = {
    callback,
    priorityLevel: currentPriorityLevel,
    expirationTime,
    next: null,
    previous: null,
  };

  // Insert the new callback into the list, ordered first by expiration, then
  // by insertion. So the new callback is inserted any other callback with
  // equal expiration.
  if (firstCallbackNode === null) {
    // This is the first callback in the list.
    firstCallbackNode = newNode.next = newNode.previous = newNode;
    ensureHostCallbackIsScheduled();
  } else {
    var next = null;
    var node = firstCallbackNode;
    do {
      if (node.expirationTime > expirationTime) {
        // The new callback expires before this one.
        next = node;
        break;
      }
      node = node.next;
    } while (node !== firstCallbackNode);

    if (next === null) {
      // No callback with a later expiration was found, which means the new
      // callback has the latest expiration in the list.
      next = firstCallbackNode;
    } else if (next === firstCallbackNode) {
      // The new callback has the earliest expiration in the entire list.
      firstCallbackNode = newNode;
      ensureHostCallbackIsScheduled();
    }

    var previous = next.previous;
    previous.next = next.previous = newNode;
    newNode.next = next;
    newNode.previous = previous;
  }

  return newNode;
}

7. ensureHostCallbackIsScheduled

  • 该方法名字就说明了目的是保证 callback 会被调度,故若已经有 callbackNode 在被调度,自会自动循环。
  • 从头结点,也就是最先过期的 callbackNode 开始请求调用,顺表如果有已存在的调用要取消。这就是之前说过的参与调用的任务有两种被打断的可能:1. 时间片到点了,2. 有更高优先级的任务参与了调度
function ensureHostCallbackIsScheduled() {
  if (isExecutingCallback) {
    // Don't schedule work yet; wait until the next time we yield.
    return;
  }
  // Schedule the host callback using the earliest expiration in the list.
  var expirationTime = firstCallbackNode.expirationTime;
  if (!isHostCallbackScheduled) {
    isHostCallbackScheduled = true;
  } else {
    // Cancel the existing host callback.
    cancelHostCallback();
  }
  requestHostCallback(flushWork, expirationTime);
}
requestHostCallback = function(callback, absoluteTimeout) {
  scheduledHostCallback = callback;
  timeoutTime = absoluteTimeout;
  
  // 超时了要立即安排调用
  if (isFlushingHostCallback || absoluteTimeout < 0) {
    // Don't wait for the next frame. Continue working ASAP, in a new event.
    window.postMessage(messageKey, '*');
  } else if (!isAnimationFrameScheduled) {
    // 没有超时,就常规安排,等待时间片
    isAnimationFrameScheduled = true;
    requestAnimationFrameWithTimeout(animationTick);
  }
};

// 取消之前安排的任务回调,就是重置一些变量
cancelHostCallback = function() {
  scheduledHostCallback = null;
  isMessageEventScheduled = false;
  timeoutTime = -1;
};

为了模拟 requestIdleCallback API:
传给 window.requestanimationframe 的回调函数会在浏览器下一次重绘之前执行,也就是执行该回调后浏览器下面会立即进入重绘。使用 window.postMessage 技巧将空闲工作推迟到重新绘制之后。
具体太过复杂,就大概听个响吧,若要深究则深究:

  • animationTick
  • idleTick
// 仅供示意
requestAnimationFrameWithTimeout(animationTick);
var animationTick = function(rafTime) {
  requestAnimationFrameWithTimeout(animationTick);
}
window.addEventListener('message', idleTick, false);
window.postMessage(messageKey, '*');

react 这里还能统计判断出平台刷新频率,来动态减少 react 自身运行所占用的时间片,支持的上限是 120hz 的刷新率,即每帧总共的时间不能低于 8ms。
此间如果一帧的时间在执行 react js 之前就已经被浏览器用完,那么对于非过期任务,等待下次时间片;而对于过期任务,会强制执行。

8. flushWork

ensureHostCallbackIsScheduled 中的 requestHostCallback(flushWork, expirationTime) 参与时间片调度:
flushWork:

  • 即使当前时间片已超时,也要把 callbackNode 链表中所有已经过期的任务先强制执行掉
  • 若当前帧还有时间片,则常规处理任务
function flushWork(didTimeout) {
  isExecutingCallback = true;
  deadlineObject.didTimeout = didTimeout;
  try {
    // 把callbackNode链表中所有已经过期的任务先强制执行掉
    if (didTimeout) {
      // Flush all the expired callbacks without yielding.
      while (firstCallbackNode !== null) {
        // Read the current time. Flush all the callbacks that expire at or
        // earlier than that time. Then read the current time again and repeat.
        // This optimizes for as few performance.now calls as possible.
        var currentTime = getCurrentTime();
        if (firstCallbackNode.expirationTime <= currentTime) {
          do {
            flushFirstCallback();
          } while (
            firstCallbackNode !== null &&
            firstCallbackNode.expirationTime <= currentTime
          );
          continue;
        }
        break;
      }
    } else {
      // 当前帧还有时间片,则继续处理任务
      // Keep flushing callbacks until we run out of time in the frame.
      if (firstCallbackNode !== null) {
        do {
          flushFirstCallback();
        } while (
          firstCallbackNode !== null &&
          getFrameDeadline() - getCurrentTime() > 0
        );
      }
    }
  } finally {
    isExecutingCallback = false;
    if (firstCallbackNode !== null) {
      // There's still work remaining. Request another callback.
      ensureHostCallbackIsScheduled();
    } else {
      isHostCallbackScheduled = false;
    }
    // Before exiting, flush all the immediate work that was scheduled.
    flushImmediateWork();
  }
}

flushFirstCallback 负责处理链表节点,然后执行 flushedNode.callback

9. performWork

  • 是否有 deadline 的区分
  • 循环渲染 Root 的条件
  • 超过时间片的处理

performSyncWork 不会传 deadline。
没有deadline时,会循环执行 root 上的同步任务,或者任务过期了,也会立马执行任务。

performAsyncWork:

function performAsyncWork(dl) {
  if (dl.didTimeout) { // 是否过期
    if (firstScheduledRoot !== null) {
      recomputeCurrentRendererTime();
      let root: FiberRoot = firstScheduledRoot;
      do {
        didExpireAtExpirationTime(root, currentRendererTime);
        // The root schedule is circular, so this is never null.
        root = (root.nextScheduledRoot: any);
      } while (root !== firstScheduledRoot);
    }
  }
  performWork(NoWork, dl);
}

performSyncWork:

function performSyncWork() {
  performWork(Sync, null);
}

performWork:

function performWork(minExpirationTime: ExpirationTime, dl: Deadline | null) {
  deadline = dl;

  // Keep working on roots until there's no more work, or until we reach
  // the deadline.
  findHighestPriorityRoot();

  if (deadline !== null) {
    recomputeCurrentRendererTime();
    currentSchedulerTime = currentRendererTime;

    if (enableUserTimingAPI) {
      const didExpire = nextFlushedExpirationTime < currentRendererTime;
      const timeout = expirationTimeToMs(nextFlushedExpirationTime);
      stopRequestCallbackTimer(didExpire, timeout);
    }

    while (
      nextFlushedRoot !== null &&
      nextFlushedExpirationTime !== NoWork &&
      (minExpirationTime === NoWork ||
        minExpirationTime >= nextFlushedExpirationTime) &&
      (!deadlineDidExpire || currentRendererTime >= nextFlushedExpirationTime)
    ) {
      performWorkOnRoot(
        nextFlushedRoot,
        nextFlushedExpirationTime,
        currentRendererTime >= nextFlushedExpirationTime,
      );
      findHighestPriorityRoot();
      recomputeCurrentRendererTime();
      currentSchedulerTime = currentRendererTime;
    }
  } else {
    while (
      nextFlushedRoot !== null &&
      nextFlushedExpirationTime !== NoWork &&
      (minExpirationTime === NoWork ||
        minExpirationTime >= nextFlushedExpirationTime)
    ) {
      performWorkOnRoot(nextFlushedRoot, nextFlushedExpirationTime, true);
      findHighestPriorityRoot();
    }
  }

  // We're done flushing work. Either we ran out of time in this callback,
  // or there's no more work left with sufficient priority.

  // If we're inside a callback, set this to false since we just completed it.
  if (deadline !== null) {
    callbackExpirationTime = NoWork;
    callbackID = null;
  }
  // If there's work left over, schedule a new callback.
  if (nextFlushedExpirationTime !== NoWork) {
    scheduleCallbackWithExpirationTime(
      ((nextFlushedRoot: any): FiberRoot),
      nextFlushedExpirationTime,
    );
  }

  // Clean-up.
  deadline = null;
  deadlineDidExpire = false;

  finishRendering();
}

performWorkOnRoot:

  • isRendering 标记现在开始渲染了
  • 判断 finishedWork:是:调用 completeRoot 进入下一章的 commit 阶段;否:调用 renderRoot 遍历 Fiber 树。
function performWorkOnRoot(
  root: FiberRoot,
  expirationTime: ExpirationTime,
  isExpired: boolean,
) {
    
  isRendering = true;

  // Check if this is async work or sync/expired work.
  if (deadline === null || isExpired) {
    // Flush work without yielding.
    // TODO: Non-yieldy work does not necessarily imply expired work. A renderer
    // may want to perform some work without yielding, but also without
    // requiring the root to complete (by triggering placeholders).

    let finishedWork = root.finishedWork;
    if (finishedWork !== null) {
      // This root is already complete. We can commit it.
      completeRoot(root, finishedWork, expirationTime);
    } else {
      root.finishedWork = null;
      // If this root previously suspended, clear its existing timeout, since
      // we're about to try rendering again.
      const timeoutHandle = root.timeoutHandle;
      if (timeoutHandle !== noTimeout) {
        root.timeoutHandle = noTimeout;
        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
        cancelTimeout(timeoutHandle);
      }
      const isYieldy = false;
      renderRoot(root, isYieldy, isExpired);
      finishedWork = root.finishedWork;
      if (finishedWork !== null) {
        // We've completed the root. Commit it.
        completeRoot(root, finishedWork, expirationTime);
      }
    }
  } else {
    // Flush async work.
    let finishedWork = root.finishedWork;
    if (finishedWork !== null) {
      // This root is already complete. We can commit it.
      completeRoot(root, finishedWork, expirationTime);
    } else {
      root.finishedWork = null;
      // If this root previously suspended, clear its existing timeout, since
      // we're about to try rendering again.
      const timeoutHandle = root.timeoutHandle;
      if (timeoutHandle !== noTimeout) {
        root.timeoutHandle = noTimeout;
        // $FlowFixMe Complains noTimeout is not a TimeoutID, despite the check above
        cancelTimeout(timeoutHandle);
      }
      const isYieldy = true;
      renderRoot(root, isYieldy, isExpired);
      finishedWork = root.finishedWork;
      if (finishedWork !== null) {
        // We've completed the root. Check the deadline one more time
        // before committing.
        if (!shouldYield()) {
          // Still time left. Commit the root.
          completeRoot(root, finishedWork, expirationTime);
        } else {
          // There's no time left. Mark this root as complete. We'll come
          // back and commit it later.
          root.finishedWork = finishedWork;
        }
      }
    }
  }

  isRendering = false;
}

10. renderRoot

  • 调用 workLoop 进行循环单元更新
  • 捕获错误并进行处理
  • 走完流程之后善后

**renderRoot **流程:

  • 遍历 Fiber 树的每个节点。

根据 Fiber 上的 updateQueue 是否有内容,决定是否要更新那个 Fiber 节点,并且计算出新的 state,
对于异步任务,更新每个 Fiber 节点时都要判断时间片是否过期,如果一个 Fiber 更新时出错,则其子节点就不用再更新了。最终整个 Fiber 树遍历完之后,根据捕获到的问题不同,再进行相应处理。

  • createWorkInProgress:renderRoot 中,调用 createWorkInProgress 创建 “workInProgress” 树,在其上进行更新操作。在 renderRoot 开始之后,所有的操作都在 “workInProgress” 树上进行,而非直接操作 “current” 树。(双buff机制)
  • workLoop:开始更新一颗 Fiber 树上的每个节点, isYieldy 指示是否可以中断,对于 sync 任务和已经超时的任务都是不可中断的,于是 while 循环更新即可;对于可中断的,则每次 while 循环条件中还要判断是否时间片到点需先退出。
function workLoop(isYieldy) {
  if (!isYieldy) {
    // Flush work without yielding
    while (nextUnitOfWork !== null) {
      nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
    }
  } else {
    // Flush asynchronous work until the deadline runs out of time.
    while (nextUnitOfWork !== null && !shouldYield()) {
      nextUnitOfWork = performUnitOfWork(nextUnitOfWork);
    }
  }
}
  • performUnitOfWork:更新子树:
function performUnitOfWork(workInProgress: Fiber): Fiber | null {
  const current = workInProgress.alternate;
  // See if beginning this work spawns more work.
  startWorkTimer(workInProgress);
  let next;
    if (enableProfilerTimer) {
    if (workInProgress.mode & ProfileMode) {
      startProfilerTimer(workInProgress);
    }

    next = beginWork(current, workInProgress, nextRenderExpirationTime);
    workInProgress.memoizedProps = workInProgress.pendingProps;

    if (workInProgress.mode & ProfileMode) {
      // Record the render duration assuming we didn't bailout (or error).
      stopProfilerTimerIfRunningAndRecordDelta(workInProgress, true);
    }
  } else {
    next = beginWork(current, workInProgress, nextRenderExpirationTime);
    workInProgress.memoizedProps = workInProgress.pendingProps;
  }
  if (next === null) {
    // If this doesn't spawn new work, complete the current work.
    next = completeUnitOfWork(workInProgress);
  }
  ReactCurrentOwner.current = null;
  return next;
}
  • beginWork:开始具体的节点更新,下一章再说。

Root 节点具体怎么遍历更新,以及不同类型组件的更新,将在下一篇探讨。


image

你可能感兴趣的:(React源码04 - Fiber Scheduler (调度器))