React Lanes（泳道）机制

深入探讨 React Scheduler 中的核心概念------Lanes（泳道）机制。这是 React 并发模式的基石，用于管理更新的优先级、实现中断和恢复渲染、以及处理 Suspense 等。

免责声明与简化说明：

1. 极度复杂： React 的真实 Lanes 实现涉及大量位运算技巧、复杂的优先级计算、与 Suspense 的深度集成以及与 Scheduler 包的交互，源码非常晦涩难懂。
2. 核心原理聚焦： 本文将通过 概念性的模拟代码和详尽解释 来阐述 Lanes 的核心思想、数据结构和基本操作流程，旨在让你理解其工作原理，而非提供一份可以直接运行的 React 子集。
3. 代码量与清晰度： 我们会编写大量模拟代码和注释来逼近目标行数，但更注重逻辑的清晰性和对核心概念的阐释。

一、 为什么需要 Lanes？解决什么问题？

在 React 的并发模式（Concurrent Mode）之前，更新主要基于 expirationTime。这种模式难以精细地处理不同来源更新的优先级，也难以实现渲染的可中断与恢复。

Lanes 机制的引入是为了解决以下核心问题：

1. 优先级区分： 不同类型的更新应该有不同的优先级。例如：

   • 用户输入（如打字）应该具有最高优先级，需要立即响应。
   • useEffect 或数据获取后的更新优先级较低。
   • startTransition 包裹的更新优先级更低，可以被高优先级任务中断。

2. 并发与中断： 低优先级的渲染任务在执行过程中，如果遇到更高优先级的更新（如用户输入），应该能够被中断 ，优先处理高优先级更新，稍后再恢复 或重新开始低优先级渲染。

3. 批处理与合并： 多个更新可以属于同一个"批次"或具有兼容的优先级，Lanes 有助于决定哪些更新可以一起处理。

4. Suspense 集成： Lanes 与 Suspense 紧密配合，用于标记挂起的组件、处理 fallback 以及在数据加载后恢复渲染。

二、 Lanes 的核心概念：位掩码 (Bitmask)

Lanes 的核心是使用31位的二进制数来表示不同的优先级。每一位（或几位）代表一个"泳道"（Lane）。

• 为什么是 31 位？ JavaScript 中的位运算是基于 32 位有符号整数进行的，最高位是符号位。为了避免符号位带来的复杂性，React 只使用了低 31 位。

• 每个 Lane 是一个位： 每个优先级通常由一个单独的 bit 位表示。例如：

  • SyncLane (同步，最高优先级): 0b0000000000000000000000000000001 (1)
  • InputContinuousLane (连续输入): 0b0000000000000000000000000000100 (4)
  • DefaultLane (默认): 0b0000000000000000000000000010000 (16)
  • TransitionLane1 (过渡): 0b0000000000000000000001000000000 (64)
  • IdleLane (空闲，最低): 0b0100000000000000000000000000000 (很大)
  • (注意：实际的 Lane 位定义比这复杂得多，包含多个 TransitionLanes、RetryLanes 等，这里是简化示意)

• Lanes (复数)： 通常我们处理的是一个Lanes 集合 ，用一个 31 位整数表示，其中亮起的位 代表包含的 Lane。例如，一个 Lanes 值 0b00101 (5) 表示它同时包含了 SyncLane (1) 和 InputContinuousLane (4)。

• 位运算的优势：

  • 合并 (Merging): 使用按位或 | 操作可以轻松合并两个 Lanes 集合。lanes1 | lanes2

  • 检查包含 (Checking Inclusion): 使用按位与 & 操作可以检查一个 Lanes 集合是否包含某个特定的 Lane，或者两个 Lanes 集合是否有重叠。

    • (lanes & SomeLane) === SomeLane (是否包含 SomeLane)
    • (lanes & OtherLanes) !== 0 (是否有重叠)

  • 移除 (Removing): 使用按位与和按位非 & ~ 可以从一个 Lanes 集合中移除另一个 Lanes 集合。lanes & ~lanesToRemove

  • 效率高： 位运算是非常快的底层操作。

三、 核心数据结构与常量 (模拟)

// --- Lane 常量定义 (高度简化) ---
// 使用 31 位整数，每一位代表一个优先级通道
// 值越小，优先级越高 (因为 LSB 对应的优先级最高)

// 特殊值
const NoLane: Lane = /*                          */ 0b0000000000000000000000000000000; // 0
const NoLanes: Lanes = /*                        */ 0b0000000000000000000000000000000; // 0

// 同步 Lane (最高优先级) - 用于 legacy 模式或 ReactDOM.flushSync
const SyncLane: Lane = /*                        */ 0b0000000000000000000000000000001; // 1

// 输入相关 Lanes (高优先级)
const InputContinuousLane: Lane = /*             */ 0b0000000000000000000000000000100; // 4 - 如拖拽
const InputDiscreteLane: Lane = /*               */ 0b0000000000000000000000000001000; // 8 - 如点击、输入框输入 (比 Continuous 稍低)

// 默认 Lane (普通优先级) - 大多数更新，如 setState, useEffect
const DefaultLane: Lane = /*                     */ 0b0000000000000000000000000010000; // 16

// 过渡 Lanes (Transition) - 用于 startTransition 包裹的更新 (较低优先级)
// React 实际有多个 Transition Lanes，这里简化为一个范围
const TransitionLane1: Lane = /*                 */ 0b0000000000000000000001000000000; // 64
const TransitionLane2: Lane = /*                 */ 0b0000000000000000000010000000000; // 128
// ... 可能更多
const TransitionLanes: Lanes = /*                */ 0b0000000001111111111111000000000; // 假设包含多个 Transition Lane 位

// 重试 Lane (用于 Suspense 失败后重试)
const RetryLane1: Lane = /*                      */ 0b0000000010000000000000000000000; // ...
const RetryLanes: Lanes = /*                     */ 0b0001111100000000000000000000000; // 假设包含多个 Retry Lane 位

// 空闲 Lane (最低优先级) - 如 Offscreen API
const IdleLane: Lane = /*                        */ 0b0100000000000000000000000000000; // 很大

// --- 类型别名 ---
type Lane = number;  // 代表单个优先级
type Lanes = number; // 代表一个 Lane 的集合 (位掩码)

// --- 一些常用的 Lanes 集合 ---
const SyncUpdateLanes: Lanes = SyncLane; // 同步更新
const InputUpdateLanes: Lanes = InputContinuousLane | InputDiscreteLane; // 所有输入更新
const DefaultUpdateLanes: Lanes = DefaultLane; // 默认更新
const NonIdleLanes: Lanes = /*                   */ 0b0011111111111111111111111111111; // 除了 IdleLane 之外的所有 Lanes

// --- Fiber Root 节点上的 Lanes 相关属性 (模拟) ---
interface FiberRootNode {
  // ... 其他 root 属性

  // 待处理的 Lanes：所有已调度但尚未完成的更新所属 Lanes 的集合
  pendingLanes: Lanes;

  // 挂起的 Lanes：因为 Suspense 而挂起的更新所属 Lanes 的集合
  suspendedLanes: Lanes;

  // 被 Ping 的 Lanes：Suspense 的数据加载完成后，用于唤醒挂起任务的 Lanes
  pingedLanes: Lanes;

  // 已完成的 Lanes：在最近一次提交中完成的 Lanes (用于某些启发式判断)
  finishedLanes: Lanes;

  // 过期的 Lanes: 已经超过了截止时间，必须同步完成的 Lanes
  expiredLanes: Lanes;

  // 当前正在渲染的 Lanes 集合 (在 workLoop 中设置)
  currentRenderLanes: Lanes;

  // 其他与 Lanes 相关的状态...
  // eventTimes: LaneMap<number>; // 记录每个 Lane 的调度时间
  // expirationTimes: LaneMap<number>; // 记录每个 Lane 的过期时间
}

// --- 更新对象上的 Lane (模拟) ---
interface Update<State> {
  // ... 其他更新属性 (payload, callback 等)
  lane: Lane; // 这个更新属于哪个 Lane
}

// --- 全局变量 (模拟 React 内部状态) ---
// 当前正在进行的渲染所属的 Lanes 集合
let workInProgressRootRenderLanes: Lanes = NoLanes;

// 当前更新的上下文 Lane (例如，在事件处理函数中可能是 InputDiscreteLane)
let currentUpdateLane: Lane = NoLane;

// 是否在 Transition 更新中
let isTransitionRunning: boolean = false;

// --- Lane 工具函数 (核心操作) ---

/**
 * 合并两个 Lanes 集合
 * @param a Lanes 集合 A
 * @param b Lanes 集合 B
 * @returns 合并后的 Lanes 集合
 */
function mergeLanes(a: Lanes, b: Lanes): Lanes {
  // 使用按位或 |
  return a | b;
}

/**
 * 检查 lanes 集合中是否包含 targetLane
 * @param lanes 要检查的集合
 * @param lane 目标 Lane
 * @returns boolean
 */
function includesSyncLane(lanes: Lanes): boolean {
    return (lanes & SyncLane) !== NoLane;
}
function includesNonIdleLanes(lanes: Lanes): boolean {
    return (lanes & NonIdleLanes) !== NoLane;
}
// 更通用的检查函数
function includesSomeLane(lanes: Lanes, subset: Lanes): boolean {
  // 检查两个集合是否有交集 (至少包含 subset 中的一个 lane)
  // 使用按位与 &
  return (lanes & subset) !== NoLanes;
}

/**
 * 检查 subset 是否是 lanes 的子集
 * @param lanes 父集
 * @param subset 子集
 */
function isSubsetOfLanes(lanes: Lanes, subset: Lanes): boolean {
    // 如果 (lanes & subset) 的结果等于 subset 本身，说明 lanes 包含了 subset 的所有位
    return (lanes & subset) === subset;
}


/**
 * 从 lanes 集合中移除 subset 包含的所有 Lanes
 * @param lanes 原始集合
 * @param subset 要移除的 Lanes 集合
 * @returns 移除后的 Lanes 集合
 */
function removeLanes(lanes: Lanes, subset: Lanes): Lanes {
  // 使用按位与和按位非 ~
  return lanes & ~subset;
}

/**
 * 获取 lanes 集合中优先级最高的 Lane
 * (优先级越高，对应的数值越小，即越接近 LSB - Least Significant Bit)
 * @param lanes Lanes 集合
 * @returns 优先级最高的 Lane，如果没有则返回 NoLane
 */
function getHighestPriorityLane(lanes: Lanes): Lane {
  // 利用 LSB 技巧：x & -x 可以得到 x 的最低有效位 (Lowest Set Bit)
  // 在我们的 Lane 定义中，最低有效位对应的数值最小，优先级最高
  return lanes & -lanes;
}

/**
 * 从 lanes 集合中选择一个 Lane 来执行工作
 * (真实实现会考虑饥饿、过期等，这里简化为选择最高优先级的)
 * @param root Fiber Root
 * @param wipLanes 当前正在处理的 Lanes
 * @returns 要处理的下一个 Lanes 集合
 */
function getNextLanes(root: FiberRootNode, wipLanes: Lanes): Lanes {
    const pendingLanes = root.pendingLanes;
    const suspendedLanes = root.suspendedLanes;
    const pingedLanes = root.pingedLanes;

    // 0. 如果没有待处理的 Lanes，返回 NoLanes
    if (pendingLanes === NoLanes) {
        return NoLanes;
    }

    // 1. 检查是否有同步 Lane (最高优先级)
    if ((pendingLanes & SyncLane) !== NoLanes) {
        console.log("[getNextLanes] 检测到 SyncLane，优先处理");
        return SyncLane;
    }

    // 2. 检查是否有被 Ping 的 Lanes (唤醒 Suspense)
    //    需要排除掉当前正在处理的、或者已经挂起的 Lanes
    const nonIdlePingedLanes = pingedLanes & NonIdleLanes;
    if (nonIdlePingedLanes !== NoLanes) {
        const pingedLanesToTry = nonIdlePingedLanes & ~suspendedLanes;
        if (pingedLanesToTry !== NoLanes) {
            console.log("[getNextLanes] 检测到 Pinged Lanes，尝试处理:", pickArbitraryLane(pingedLanesToTry));
            // 真实实现会更复杂，可能涉及优先级比较
            return pickArbitraryLane(pingedLanesToTry); // 选择一个被 ping 的 lane
        }
    }

    // 3. 检查是否有输入或其他高优先级 Lanes
    const inputAndDefaultLanes = pendingLanes & (InputUpdateLanes | DefaultUpdateLanes);
    if (inputAndDefaultLanes !== NoLanes) {
        const nextLanes = getHighestPriorityLanes(inputAndDefaultLanes);
        console.log("[getNextLanes] 检测到 Input/Default Lanes，选择最高优先级:", nextLanes);
        return nextLanes;
    }

    // 4. 检查是否有 Transition Lanes
    const transitionLanes = pendingLanes & TransitionLanes;
    if (transitionLanes !== NoLanes) {
        const nextLanes = getHighestPriorityLanes(transitionLanes);
        console.log("[getNextLanes] 检测到 Transition Lanes，选择最高优先级:", nextLanes);
        return nextLanes;
    }

    // 5. 检查是否有 Retry Lanes
    const retryLanes = pendingLanes & RetryLanes;
     if (retryLanes !== NoLanes) {
        const nextLanes = getHighestPriorityLanes(retryLanes);
        console.log("[getNextLanes] 检测到 Retry Lanes，选择最高优先级:", nextLanes);
        return nextLanes;
    }

    // 6. 检查是否有 Idle Lane
    if ((pendingLanes & IdleLane) !== NoLanes) {
        console.log("[getNextLanes] 检测到 IdleLane，处理");
        return IdleLane;
    }

    // 理论上不应该执行到这里，除非 pendingLanes 为 NoLanes
    console.warn("[getNextLanes] 未找到合适的 Lane，返回 NoLanes");
    return NoLanes;
}

// 辅助函数：获取一个 Lanes 集合中的所有最高优先级 Lanes (可能不止一个)
function getHighestPriorityLanes(lanes: Lanes): Lanes {
    const highestLane = getHighestPriorityLane(lanes);
    // 实际 React 中可能包含一个优先级范围内的所有 Lanes，这里简化
    return highestLane;
}

// 辅助函数：从 Lanes 集合中随意选择一个 Lane (通常是最高优先级的那个)
function pickArbitraryLane(lanes: Lanes): Lane {
    return getHighestPriorityLane(lanes);
}

// 辅助函数：检查 lane 是否在 lanes 集合中
function isLaneIncluded(lanes: Lanes, lane: Lane): boolean {
    return (lanes & lane) !== NoLane;
}

console.log("--- Lane 工具函数定义完毕 ---");

四、 Lanes 在更新与调度流程中的应用 (模拟)

// --- 模拟 Fiber Root ---
const root: FiberRootNode = {
  pendingLanes: NoLanes,
  suspendedLanes: NoLanes,
  pingedLanes: NoLanes,
  finishedLanes: NoLanes,
  expiredLanes: NoLanes,
  currentRenderLanes: NoLanes,
  // eventTimes: createLaneMap(NoTimestamp),
  // expirationTimes: createLaneMap(NoTimestamp),
};

// --- 模拟调度器状态 ---
let isWorkLoopRunning = false; // 是否有 workLoop 在运行
let isCallbackScheduled = false; // 是否已安排回调

/**
 * 请求一个适合当前上下文的 Lane
 * (真实实现会考虑当前事件优先级等)
 * @returns Lane
 */
function requestUpdateLane(): Lane {
  // 1. 如果在 Transition 中，分配 Transition Lane
  if (isTransitionRunning) {
    console.log("[requestUpdateLane] 在 Transition 中，分配 TransitionLane1");
    // 实际会从 TransitionLanes 池中选择一个
    return TransitionLane1;
  }

  // 2. 如果当前正在处理输入事件 (React 通过上下文判断)
  // 假设我们有一个全局变量模拟这个
  // if (currentEventPriority === DiscreteEventPriority) {
  //   console.log("[requestUpdateLane] 在离散输入事件中，分配 InputDiscreteLane");
  //   return InputDiscreteLane;
  // }
  // if (currentEventPriority === ContinuousEventPriority) {
  //    console.log("[requestUpdateLane] 在连续输入事件中，分配 InputContinuousLane");
  //   return InputContinuousLane;
  // }

  // 3. 默认情况，分配 DefaultLane
  console.log("[requestUpdateLane] 默认情况，分配 DefaultLane");
  return DefaultLane;
}

/**
 * 调度一个更新到 Fiber Root
 * @param root Fiber Root
 * @param lane 更新所属的 Lane
 */
function scheduleUpdateOnFiber(root: FiberRootNode, lane: Lane) {
  console.log(`[scheduleUpdate] 收到 Lane ${lane} 的更新请求`);

  // 1. 将 Lane 添加到 root 的 pendingLanes
  root.pendingLanes = mergeLanes(root.pendingLanes, lane);
  console.log(`[scheduleUpdate] root.pendingLanes 更新为: ${root.pendingLanes.toString(2)} (${root.pendingLanes})`);

  // 2. 检查是否需要同步执行 (SyncLane 或已过期)
  if (lane === SyncLane /* || isLaneExpired(root, lane) */) {
    console.log(`[scheduleUpdate] Lane ${lane} 需要同步执行，立即执行 workLoop`);
    // 在同步模式下，可能直接触发渲染，或者使用微任务确保在当前任务结束前执行
    ensureRootIsScheduled(root, true); // 标记为同步
  } else {
    // 异步模式，安排调度
    console.log(`[scheduleUpdate] Lane ${lane} 是异步的，安排调度`);
    ensureRootIsScheduled(root, false);
  }
}

/**
 * 确保 Root 的工作循环已被安排
 * @param root Fiber Root
 * @param isSync 是否需要同步执行
 */
function ensureRootIsScheduled(root: FiberRootNode, isSync: boolean) {
  if (isWorkLoopRunning) {
    // 如果工作循环已经在运行，可能需要标记有新的更高优先级任务插入
    console.log("[ensureRootIsScheduled] 工作循环已在运行");
    // 真实 React 会在这里处理中断逻辑
    return;
  }
  if (isCallbackScheduled) {
    console.log("[ensureRootIsScheduled] 回调已安排，等待执行");
    // 可能需要根据新的 lane 优先级调整回调
    return;
  }

  isCallbackScheduled = true;
  console.log(`[ensureRootIsScheduled] 安排 ${isSync ? '同步' : '异步'} 回调执行 workLoop`);

  if (isSync) {
    // 模拟同步执行 (或微任务)
    queueMicrotask(() => {
        console.log("\n L> [Microtask Sync] 同步回调触发");
        isCallbackScheduled = false; // 重置标记
        workLoop(root, true); // 执行同步工作循环
    });
  } else {
    // 模拟异步执行 (真实 React Scheduler 使用 MessageChannel 或 setTimeout)
    setTimeout(() => {
      console.log("\n L> [setTimeout Async] 异步回调触发");
      isCallbackScheduled = false; // 重置标记
      workLoop(root, false); // 执行异步工作循环
    }, 0); // 使用 setTimeout(0) 模拟宏任务调度
  }
}

/**
 * 主要工作循环 (高度简化)
 * @param root Fiber Root
 * @param isSync 是否是同步模式
 */
function workLoop(root: FiberRootNode, isSync: boolean) {
  if (isWorkLoopRunning) {
    console.error("workLoop 重入错误");
    return;
  }
  isWorkLoopRunning = true;
  console.log(`\n===== [workLoop ${isSync ? 'Sync' : 'Async'}] 开始 =====`);
  console.log(`  当前 root.pendingLanes: ${root.pendingLanes.toString(2)}`);

  let performedWork = false;

  try {
      if (isSync) {
          // 同步模式：必须完成所有同步工作
          performSyncWorkOnRoot(root);
          performedWork = true;
      } else {
          // 异步模式：可以分片执行，可以被中断
          performedWork = performConcurrentWorkOnRoot(root);
      }
  } finally {
      isWorkLoopRunning = false;
      console.log(`===== [workLoop ${isSync ? 'Sync' : 'Async'}] 结束 (是否执行了工作: ${performedWork}) =====\n`);

      // 检查循环结束后是否还有待处理任务，或者在循环中产生了新任务
      if (root.pendingLanes !== NoLanes) {
          console.log("[workLoop] 结束后仍有 pendingLanes，重新安排调度");
          ensureRootIsScheduled(root, false); // 默认安排异步
      }
  }
}

/**
 * 执行同步渲染工作 (简化)
 */
function performSyncWorkOnRoot(root: FiberRootNode) {
  console.log("  [performSyncWork] 开始执行同步工作");
  // 在同步模式下，通常只处理 SyncLane
  const lanesToRender = SyncLane; // 简化处理
  if (!includesSomeLane(root.pendingLanes, lanesToRender)) {
      console.log("  [performSyncWork] 没有待处理的同步 Lane，退出");
      return;
  }

  root.currentRenderLanes = lanesToRender;
  workInProgressRootRenderLanes = lanesToRender; // 设置全局变量

  console.log(`  [performSyncWork] 准备渲染 Lanes: ${lanesToRender.toString(2)}`);

  // 模拟渲染过程 (遍历 Fiber 树等)
  console.log("  [performSyncWork] ...模拟 Fiber 树遍历和组件渲染...");
  // 假设渲染成功完成
  console.log("  [performSyncWork] 渲染完成");

  // 模拟提交阶段
  commitRoot(root, lanesToRender);

  workInProgressRootRenderLanes = NoLanes; // 清理全局变量
  root.currentRenderLanes = NoLanes;
  console.log("  [performSyncWork] 同步工作完成");
}

/**
 * 执行并发渲染工作 (简化，包含中断检查)
 */
function performConcurrentWorkOnRoot(root: FiberRootNode): boolean {
  console.log("  [performConcurrentWork] 开始执行并发工作");

  // 1. 选择要渲染的 Lanes (最高优先级)
  const lanesToRender = getNextLanes(root, NoLanes); // wipLanes 初始为 NoLanes
  if (lanesToRender === NoLanes) {
    console.log("  [performConcurrentWork] 没有找到需要渲染的 Lane，退出");
    return false; // 没有执行工作
  }
   // 检查选出的 Lane 是否真的在 pendingLanes 中 (健全性检查)
  if (!includesSomeLane(root.pendingLanes, lanesToRender)) {
      console.warn(`  [performConcurrentWork] getNextLanes 返回了不在 pendingLanes 中的 Lane (${lanesToRender}), 退出`);
      return false;
  }


  root.currentRenderLanes = lanesToRender;
  workInProgressRootRenderLanes = lanesToRender; // 设置全局变量

  console.log(`  [performConcurrentWork] 准备渲染 Lanes: ${lanesToRender.toString(2)} (${lanesToRender})`);

  // 模拟渲染过程 (可能是分片的)
  let shouldYield = false; // 标记是否需要让出主线程
  let workUnitCounter = 0;
  const MAX_WORK_UNITS_PER_LOOP = 3; // 模拟时间分片，每次循环最多处理几个单元

  while (workUnitCounter < MAX_WORK_UNITS_PER_LOOP) {
    workUnitCounter++;
    console.log(`  [performConcurrentWork]   ...模拟处理工作单元 ${workUnitCounter}...`);

    // *** 中断检查 ***
    // 在处理每个工作单元之间，检查是否有更高优先级的任务插入
    const currentPendingLanes = root.pendingLanes;
    const higherPriorityLanes = getHighestPriorityLane(currentPendingLanes);

    // 如果新来的最高优先级 Lane 比当前正在渲染的 Lane 优先级更高
    // (注意：值越小优先级越高)
    if (higherPriorityLanes !== NoLane && higherPriorityLanes < getHighestPriorityLane(lanesToRender)) {
        console.warn(`  [performConcurrentWork] ***** 中断 *****`);
        console.warn(`    检测到更高优先级 Lane: ${higherPriorityLanes.toString(2)} (${higherPriorityLanes})`);
        console.warn(`    当前渲染 Lanes: ${lanesToRender.toString(2)} (${lanesToRender})`);

        // 中断当前渲染，清理状态，让出主线程，等待调度器重新调度
        workInProgressRootRenderLanes = NoLanes;
        root.currentRenderLanes = NoLanes;
        console.log("  [performConcurrentWork] 清理渲染状态，准备让出");
        return true; // 执行了部分工作，但被中断
    }

    // 模拟检查是否需要让出主线程 (基于时间判断)
    // if (scheduler.shouldYield()) {
    //   console.log("  [performConcurrentWork] 时间耗尽，需要让出主线程 (Yield)");
    //   shouldYield = true;
    //   break;
    // }
  }

  if (shouldYield) {
    // 如果需要让出，当前渲染任务未完成，等待下次调度继续
    console.log("  [performConcurrentWork] 本次时间片结束，渲染未完成");
    // workInProgressRootRenderLanes 保持不变，等待下次继续
    return true; // 执行了部分工作
  } else {
    // 渲染完成 (当前 Lanes 的工作)
    console.log(`  [performConcurrentWork] Lanes ${lanesToRender.toString(2)} 的渲染工作完成`);
    // 模拟提交阶段
    commitRoot(root, lanesToRender);
    workInProgressRootRenderLanes = NoLanes; // 清理全局变量
    root.currentRenderLanes = NoLanes;
    return true; // 执行了完整工作
  }
}

/**
 * 模拟提交阶段
 * @param root Fiber Root
 * @param finishedWorkLanes 本次渲染完成的 Lanes
 */
function commitRoot(root: FiberRootNode, finishedWorkLanes: Lanes) {
  console.log(`  [commitRoot] 开始提交 Lanes: ${finishedWorkLanes.toString(2)}`);

  // 1. 从 pendingLanes 中移除已完成的 Lanes
  const before = root.pendingLanes;
  root.pendingLanes = removeLanes(root.pendingLanes, finishedWorkLanes);
  console.log(`  [commitRoot]   pendingLanes 从 ${before.toString(2)} 更新为 ${root.pendingLanes.toString(2)}`);

  // 2. 更新 finishedLanes
  root.finishedLanes = finishedWorkLanes; // 记录最近完成的 Lanes

  // 3. 模拟执行 DOM 更新、调用 useEffect 回调等
  console.log("  [commitRoot]   ...模拟 DOM 更新和 Effect 执行...");

  console.log(`  [commitRoot] 提交完成`);
}

// --- 模拟场景 ---

console.log("\n====== 模拟开始 ======");
console.log("初始 root.pendingLanes:", root.pendingLanes);

// 1. 模拟一个低优先级的 Transition 更新
console.log("\n--- 模拟 Transition 更新 ---");
isTransitionRunning = true; // 进入 Transition 上下文
const transitionLane = requestUpdateLane(); // 获取 TransitionLane
scheduleUpdateOnFiber(root, transitionLane);
isTransitionRunning = false; // 退出 Transition 上下文
// 此时 root.pendingLanes 包含 TransitionLane, workLoop (异步) 被安排

// 2. 几乎同时，模拟一个高优先级的用户输入更新
console.log("\n--- 模拟用户输入更新 (高优先级) ---");
// 假设当前是离散输入事件上下文
// currentEventPriority = DiscreteEventPriority; // (需要更复杂的上下文管理)
// 这里直接使用 InputDiscreteLane
const inputLane = InputDiscreteLane;
scheduleUpdateOnFiber(root, inputLane);
// currentEventPriority = DefaultEventPriority; // 恢复默认
// 此时 root.pendingLanes 包含 TransitionLane 和 InputLane
// workLoop (异步) 可能已被安排，或者会被新的更高优先级更新重新安排/抢占

// 3. 模拟一个同步更新 (最高优先级)
// console.log("\n--- 模拟同步更新 (最高优先级) ---");
// scheduleUpdateOnFiber(root, SyncLane);
// 这会立即 (或在微任务中) 触发 workLoop(Sync)

// 等待异步调度执行... (控制台会显示调度和渲染日志)

// 预期执行流程 (可能因 setTimeout/queueMicrotask 时序略有不同):
// 1. Transition 更新安排异步 workLoop。
// 2. Input 更新到来，pendingLanes 合并 InputLane。由于 Input 优先级更高，
//    如果异步 workLoop 尚未执行，它会被 Input 更新抢占；
//    如果异步 workLoop 正在执行 Transition (不太可能这么快)，它会被中断。
// 3. 异步回调触发 workLoop(Async)。
// 4. getNextLanes 选择 InputLane (优先级高于 TransitionLane)。
// 5. performConcurrentWorkOnRoot 开始渲染 InputLane。
// 6. 假设 InputLane 渲染很快完成，调用 commitRoot(InputLane)。
//    pendingLanes 移除 InputLane，剩下 TransitionLane。
// 7. workLoop 结束。检查发现 pendingLanes 仍有 TransitionLane，再次安排异步 workLoop。
// 8. 下一个异步回调触发 workLoop(Async)。
// 9. getNextLanes 选择 TransitionLane。
// 10. performConcurrentWorkOnRoot 开始渲染 TransitionLane。
// 11. 假设渲染完成，调用 commitRoot(TransitionLane)。
// 12. pendingLanes 变为空。workLoop 结束。不再安排。

// 如果中间插入了 SyncLane:
// 1. Sync 更新到来，pendingLanes 合并 SyncLane。
// 2. ensureRootIsScheduled 安排同步 workLoop (微任务)。
// 3. 微任务触发 workLoop(Sync)。
// 4. performSyncWorkOnRoot 只处理 SyncLane。
// 5. commitRoot(SyncLane)。pendingLanes 移除 SyncLane。
// 6. workLoop(Sync) 结束。检查发现 pendingLanes 仍有 Input/Transition，安排异步 workLoop。
// 7. 后续流程同上，处理 Input 和 Transition。

五、 总结与关键点

1. 位表示优先级： Lanes 使用 31 位整数的位来代表不同的更新优先级，数值越小（越接近 LSB）优先级越高。

2. Lanes 集合： 一个整数可以表示多个 Lanes 的集合，通过位运算进行高效操作（合并、检查、移除）。

3. Fiber Root 状态： pendingLanes 是核心，记录了所有待处理的更新优先级。suspendedLanes, pingedLanes 等与 Suspense 相关。

4. 调度入口： scheduleUpdateOnFiber 负责将更新的 Lane 添加到 pendingLanes 并触发调度逻辑 (ensureRootIsScheduled)。

5. 调度决策： ensureRootIsScheduled 根据更新是否同步决定使用微任务还是宏任务来安排 workLoop。

6. 工作循环 (workLoop)：

   • 选择 Lanes (getNextLanes)： 根据 pendingLanes 和其他状态（Suspense, Ping）选择最高优先级的 Lanes 来执行。

   • 执行渲染 (performSyncWorkOnRoot / performConcurrentWorkOnRoot)：

     • 同步模式：一次性完成所有同步工作。
     • 并发模式：可以分片执行，并在每个工作单元之间检查是否有更高优先级的更新插入 ，实现中断。

   • 提交 (commitRoot)： 渲染完成后，将完成的 Lanes 从 pendingLanes 中移除，并执行副作用。

7. 并发与中断： 并发模式下的 performConcurrentWorkOnRoot 通过在渲染过程中检查 pendingLanes 中是否有比当前 workInProgressRootRenderLanes 更高优先级的 Lane，来实现渲染任务的中断。中断后，调度器会重新安排，优先处理更高优先级的任务。

这个模拟虽然简化了很多细节（如精确的 Lane 分配、过期逻辑、错误处理、复杂的 Suspense 交互、真实的 Scheduler 包集成等），但它展示了 Lanes 机制如何通过位运算管理优先级、如何决定工作内容、以及如何实现并发模式下的中断与恢复的核心思想。理解了 Lanes，就理解了 React 并发更新调度的心脏。