ReactDOM.render 做了什么? ​

render(
    element: React$Element<any>,
    container: DOMContainer,
    callback: ?Function,
  ) {
    return legacyRenderSubtreeIntoContainer(
      null,
      element,
      container,
      false,
      callback,
    );
  }

function legacyRenderSubtreeIntoContainer(
  // 父节点
  parentComponent: ?React$Component<any, any>, 
  // ReactDOM.render的第一个参数对应的ReactElement
  children: ReactNodeList,
  // ReactDOM.render的第二个参数 
  container: DOMContainer,
  // 服务端渲染相关
  forceHydrate: boolean,
  callback: ?Function,
) {
  // 在dom节点增加属性_reactRootContainer
  let root: Root = (container._reactRootContainer: any);
  if (!root) {
    // 创建ReactRoot
    root = container._reactRootContainer = legacyCreateRootFromDOMContainer(
      container,
      forceHydrate,
    );
    if (typeof callback === 'function') {
      const originalCallback = callback;
      callback = function() {
        const instance = getPublicRootInstance(root._internalRoot);
        originalCallback.call(instance);
      };
    }
    // render方法,放在unbatchedUpdates里面更新
    // 意思是当前的更新不需要批量更新，因为是首次渲染，所以会尽快渲染出页面
    unbatchedUpdates(() => {
      // 执行ReactRoot的render方法
      root.render(children, callback);
    });
  } else {
    /** do some things **/
  }
  return getPublicRootInstance(root._internalRoot);
}

function legacyCreateRootFromDOMContainer(
  container: DOMContainer,
  forceHydrate: boolean,
): Root {
  // 在目前的版本中 concurrent mode 默认是关闭的
  const isConcurrent = false;
  return new ReactRoot(container, isConcurrent, shouldHydrate);
}

function ReactRoot(
  container: DOMContainer,
  isConcurrent: boolean,
  hydrate: boolean,
) {
  // 创建FiberRoot节点
  const root = createContainer(container, isConcurrent, hydrate);
  this._internalRoot = root;
}

ReactRoot.prototype.render = function(
  children: ReactNodeList,
  callback: ?() => mixed,
): Work {
  const root = this._internalRoot;
  updateContainer(children, root, null, work._onCommit);
};

export function createFiberRoot(
  containerInfo: any,
  isConcurrent: boolean,
  hydrate: boolean,
): FiberRoot {
  // 创建RootFiber
  const uninitializedFiber = createHostRootFiber(isConcurrent);
  
  // 当前root是FiberRoot
  let root = ({
    // 指向RootFiber
    current: uninitializedFiber,
    // 指向root的dom节点
    containerInfo: containerInfo,
    pendingChildren: null,
    pingCache: null,
    earliestPendingTime: NoWork,
    latestPendingTime: NoWork,
    earliestSuspendedTime: NoWork,
    latestSuspendedTime: NoWork,
    latestPingedTime: NoWork,
    didError: false,
    pendingCommitExpirationTime: NoWork,
    finishedWork: null,
    timeoutHandle: noTimeout,
    context: null,
    pendingContext: null,
    hydrate,
    nextExpirationTimeToWorkOn: NoWork,
    expirationTime: NoWork,
    firstBatch: null,
    nextScheduledRoot: null,
  }: BaseFiberRootProperties);
  
  // 将RootFiber的stateNode指向 FiberRoot
  uninitializedFiber.stateNode = root;
  
  return root
}

export function createHostRootFiber(isConcurrent: boolean): Fiber {
  // 当前版本中，还没有开启ConcurrentMode
  let mode = isConcurrent ? ConcurrentMode | StrictMode : NoContext;
  if (enableProfilerTimer && isDevToolsPresent) {
    mode |= ProfileMode;
  }
  return createFiber(HostRoot, null, null, mode);
}