React源码解析之ExpirationTime

1、ExpirationTime的做用
在React中，为防止某个update由于优先级的缘由一直被打断而未能执行。React会设置一个ExpirationTime，当时间到了ExpirationTime的时候，若是某个update还未执行的话，React将会强制执行该update，这就是ExpirationTime的做用。

2、位置
在React源码解析之ReactDOM.render()中，已经讲解了updateContainer()：

export function updateContainer(
  element: ReactNodeList,
  container: OpaqueRoot,
  parentComponent: ?React$Component<any, any>,
  callback: ?Function,
): ExpirationTime {
   ...
   //计算过时时间，这是React优先级更新很是重要的点
  const expirationTime = computeExpirationForFiber(
    currentTime,
    current,
    suspenseConfig,
  );
   ...
}
复制代码

computeExpirationForFiber：

//为fiber对象计算expirationTime
export function computeExpirationForFiber(
  currentTime: ExpirationTime,
  fiber: Fiber,
  suspenseConfig: null | SuspenseConfig,
): ExpirationTime {
  ...
  // Compute an expiration time based on the Scheduler priority.
    switch (priorityLevel) {
      case ImmediatePriority:
        expirationTime = Sync;
        break;
      case UserBlockingPriority:
        // TODO: Rename this to computeUserBlockingExpiration
        //一个是计算交互事件（如点击）的过时时间
        expirationTime = computeInteractiveExpiration(currentTime);
        break;
      case NormalPriority:
      case LowPriority: // TODO: Handle LowPriority
        // TODO: Rename this to... something better.
        //一个是计算异步更新的过时时间
        expirationTime = computeAsyncExpiration(currentTime);
        break;
      case IdlePriority:
        expirationTime = Never;
        break;
      default:
        invariant(false, 'Expected a valid priority level');
    }
  ...
}
复制代码

咱们能够看到有两个计算expirationTime的方法，分别为computeInteractiveExpiration()和computeAsyncExpiration()

先看下computeAsyncExpiration()

3、computeAsyncExpiration()
做用：
返回低优先级（普通异步更新）的expirationTime（过时时间）

源码：

//低权限的过时时间
export const LOW_PRIORITY_EXPIRATION = 5000;
export const LOW_PRIORITY_BATCH_SIZE = 250;
//普通的异步的expirationTime
export function computeAsyncExpiration(
  currentTime: ExpirationTime,
): ExpirationTime {
  return computeExpirationBucket(
    currentTime,
    //5000
    LOW_PRIORITY_EXPIRATION,
    //250
    LOW_PRIORITY_BATCH_SIZE,
  );
}
复制代码

解析：
currentTime先按下不表，LOW_PRIORITY_EXPIRATION即5000，LOW_PRIORITY_BATCH_SIZE即250，注意它的名字LOW_PRIORITY_BATCH_SIZE，下面会提到

4、computeExpirationBucket()
做用：
计算过时时间

源码：

//1073741823
export const Sync = MAX_SIGNED_31_BIT_INT;
//1073741822
export const Batched = Sync - 1;

const UNIT_SIZE = 10;
//1073741821
const MAGIC_NUMBER_OFFSET = Batched - 1;

function ceiling(num: number, precision: number): number {
  return (((num / precision) | 0) + 1) * precision;
}

//计算过时时间
function computeExpirationBucket(
  currentTime,
  expirationInMs,
  bucketSizeMs,
): ExpirationTime {
  return (
    //1073741821
    MAGIC_NUMBER_OFFSET -
    ceiling(
      //   1073741821-currentTime+(high 150 或者 low 5000  /10)  ,
      MAGIC_NUMBER_OFFSET - currentTime + expirationInMs / UNIT_SIZE,
      //(high 100 或者 low 250  /10 )
      bucketSizeMs / UNIT_SIZE,
    )
  );
}
复制代码

解析：
（1）MAX_SIGNED_31_BIT_INT

// Max 31 bit integer. The max integer size in V8 for 32-bit systems.
// Math.pow(2, 30) - 1
// 0b111111111111111111111111111111
//整型最大数值，是V8中针对32位系统所设置的最大值
export default 1073741823;
复制代码

（2）| 0的意思是取整

console.log(16/3 |0) //5
复制代码

（3）根据computeExpirationBucket()里面的公式，计算下异步更新的过时时间：

   //low 状况
  1073741821-ceiling(1073741821-currentTime+500,25)

  1073741821-((((1073741821-currentTime+500) / 25) | 0) + 1) * 25

  1073741821-((1073741821/25-currentTime/25+20 | 0) + 1) * 25

  1073741821-((1073741821/25-currentTime/25+20*25/25 | 0) + 1) * 25

  1073741821-((1073741821-currentTime+500)/25 | 0)*25 - 25

  1073741796-((1073741821-currentTime+500)/25 | 0)*25

  1073741796-((1073742321-currentTime)/25 | 0)*25
  //======咱们直接取最后四位来探索规律===================
  1796-((2321-currentTime)/25 | 0)*25
  //假设 currentTime 是 2000
  1796-(2321- 2000 /25 | 0)*25 //1796-300
  //currentTime是2010
  1796-(311/25 | 0)*25 //1796-300
  //currentTime是2024
  1796-(311/25 | 0)*25 //1796-275
  //currentTime是2025
  1796-(311/25 | 0)*25 //1796-275
复制代码

能够看到，低优先的过时时间间隔是25ms
同理，高优先级的过时时间间隔是10ms

  //high 状况
  1073741821-ceiling(1073741821-currentTime+15,10)
复制代码

也就是说，React低优先级update的expirationTime间隔是25ms， React让两个相近（25ms内）的update获得相同的expirationTime，目的就是让这两个update自动合并成一个Update，从而达到批量更新的目的，就像LOW_PRIORITY_BATCH_SIZE的名字同样，自动合并批量更新。

想象一下，开发者不停地使用setState()更新ReactApp，若是不把相近的update合并的话，会严重影响性能，就像提到的doubleBuffer同样，React为提升性能，考虑得很是全面！

Github：
github.com/AttackXiaoJ…

---

（完）