React Concurrent Mode, introduced in React 18, is a transformative feature designed to enhance application performance and user experience through asynchronous rendering and task scheduling. This tutorial thoroughly explores the principles of Concurrent Mode, focusing on its source code implementation, including the Fiber architecture, Scheduler, Lane model, and concurrent features like useTransition. By the end, you’ll gain a comprehensive understanding of how React achieves seamless rendering in high-load scenarios.
Introduction to Concurrent Mode
What is Concurrent Mode?
Concurrent Mode is a rendering strategy in React that allows tasks to be interrupted and resumed, prioritizing urgent updates (e.g., user interactions) while deferring non-urgent tasks (e.g., data loading) to browser idle periods. Built on the Fiber architecture, it leverages time slicing and priority scheduling.
Example Scenario
- When a user types rapidly in an input field, React prioritizes updating the input content.
- Concurrently, a large data list may be rendering in the background, and Concurrent Mode ensures the input remains responsive.
Core Goals
- Responsiveness: Ensure high-priority tasks (e.g., user events) are handled quickly.
- Smoothness: Prevent main thread blocking for fluid UI updates.
- Flexibility: Support dynamic task priority adjustments.
Key Features
- Time Slicing: Breaks long tasks into smaller chunks.
- Priority Scheduling: Manages tasks via Scheduler and Lane model.
- Asynchronous Rendering: Supports interrupting and resuming rendering.
Example: Enabling Concurrent Mode
import { createRoot } from 'react-dom/client';
const root = createRoot(document.getElementById('root'), { concurrent: true });
root.render(<App />);Core Principles of Concurrent Mode
Foundation: Fiber Architecture
Concurrent Mode relies on the Fiber architecture, where each component corresponds to a Fiber node. Fiber breaks rendering into interruptible work units (Work), enabling pausing and resuming.
Fiber Node Structure
const fiber = {
tag: FunctionComponent, // Component type
type: App, // Component function
memoizedState: null, // State
updateQueue: null, // Update queue
child: null, // Child Fiber
sibling: null, // Sibling Fiber
return: null, // Parent Fiber
lanes: NoLanes, // Priority lanes
effectTag: NoEffect // Side effect tag
};Lane Model: Priority Management
The Lane model is a central mechanism in Concurrent Mode, using a 32-bit integer to represent task priorities, with each bit (Lane) indicating a priority state.
Lane Definitions
// react-reconciler/src/ReactFiberLane.js
const NoLanes = 0b0000000000000000000000000000000;
const SyncLane = 0b0000000000000000000000000000001; // Synchronous
const InputContinuousLane = 0b0000000000000000000000000010; // User interaction
const DefaultLane = 0b0000000000000000000000000100; // Default
const TransitionLane = 0b0000000000000000000000010000; // Transition
const IdleLane = 0b0100000000000000000000000000000; // Idle- Bit Operations: Uses
&and|to manage multiple priorities. - Priority Order: Lower bits represent higher priorities.
Time Slicing and Scheduling
The Scheduler module (scheduler package) splits tasks into chunks and schedules them during browser idle time, using MessageChannel or requestIdleCallback.
Example: Sliced Rendering
function workLoop(hasTimeRemaining) {
while (workInProgress !== null && hasTimeRemaining()) {
workInProgress = performUnitOfWork(workInProgress);
}
}Source Code Analysis of Concurrent Mode
Below, we analyze Concurrent Mode’s implementation based on React 18’s source code (react-reconciler and scheduler).
Rendering Entry: scheduleUpdateOnFiber
Concurrent rendering begins with scheduleUpdateOnFiber:
// react-reconciler/src/ReactFiberWorkLoop.js
function scheduleUpdateOnFiber(fiber, lane) {
markRootUpdated(fiberRoot, lane); // Mark priority
ensureRootIsScheduled(fiberRoot); // Schedule
}
function markRootUpdated(root, lane) {
root.pendingLanes |= lane; // Update pending lanes
}
function ensureRootIsScheduled(root) {
const highestLane = getHighestPriorityLane(root.pendingLanes);
if (highestLane === NoLane) return;
const priority = laneToSchedulerPriority(highestLane);
scheduleCallback(priority, () => performConcurrentWorkOnRoot(root, highestLane));
}pendingLanes: Tracks all pending priority lanes.scheduleCallback: Invokes Scheduler to schedule tasks.
Concurrent Rendering Loop: performConcurrentWorkOnRoot
The main rendering function for Concurrent Mode:
function performConcurrentWorkOnRoot(root, lane) {
renderRootConcurrent(root, lane); // Concurrent rendering
const finishedWork = root.current.alternate;
root.finishedWork = finishedWork;
root.finishedLanes = lane;
commitRoot(root); // Commit
}
function renderRootConcurrent(root, lanes) {
do {
try {
workLoopConcurrent();
break;
} catch (error) {
handleError(root, error);
}
} while (true);
}
function workLoopConcurrent() {
while (workInProgress !== null && !shouldYield()) {
workInProgress = performUnitOfWork(workInProgress);
}
}shouldYield: Provided by Scheduler, checks if rendering should pause.
Scheduler Implementation
The Scheduler (scheduler/src/Scheduler.js) drives time slicing:
function scheduleCallback(priorityLevel, callback) {
const task = {
callback,
priorityLevel,
expirationTime: getCurrentTime() + timeoutFromPriority(priorityLevel)
};
push(taskQueue, task);
requestHostCallback(flushWork);
}
function flushWork(hasTimeRemaining) {
while (peek(taskQueue) !== null && hasTimeRemaining()) {
const task = pop(taskQueue);
task.callback();
}
}
function shouldYieldToHost() {
return getCurrentTime() - frameStartTime >= yieldInterval; // Default 5ms
}Lane Priority Scheduling
Lanes determine rendering order:
function getHighestPriorityLane(lanes) {
return lanes & -lanes; // Get lowest bit (highest priority)
}
function laneToSchedulerPriority(lane) {
if (lane === SyncLane) return ImmediatePriority;
if (lane === InputContinuousLane) return UserBlockingPriority;
if (lane === DefaultLane) return NormalPriority;
if (lane === TransitionLane) return LowPriority;
return IdlePriority;
}performUnitOfWork: Task Execution
Processing each Fiber node:
function performUnitOfWork(unitOfWork) {
const current = unitOfWork.alternate;
let next = beginWork(current, unitOfWork, renderLanes);
if (next === null) {
next = completeUnitOfWork(unitOfWork);
}
return next;
}
function beginWork(current, workInProgress, renderLanes) {
if (current !== null && includesSomeLane(workInProgress.lanes, renderLanes)) {
return bailoutOnAlreadyFinishedWork(current, workInProgress);
}
switch (workInProgress.tag) {
case FunctionComponent:
return updateFunctionComponent(current, workInProgress, renderLanes);
// ...
}
}commitRoot: Commit Phase
After concurrent rendering, commit changes:
function commitRoot(root) {
const finishedWork = root.finishedWork;
commitBeforeMutationEffects(root, finishedWork);
commitMutationEffects(root, finishedWork);
root.current = finishedWork;
commitLayoutEffects(root, finishedWork);
}Source Analysis of Concurrent Features
useTransition
useTransition marks low-priority updates:
function useTransition() {
const [isPending, setPending] = useState(false);
const startTransition = (callback) => {
setPending(true);
scheduleUpdateOnFiber(currentlyRenderingFiber, TransitionLane);
callback();
setPending(false);
};
return [isPending, startTransition];
}- Uses
TransitionLaneto defer execution.
Concurrent Root
The root node for Concurrent Mode:
function createRoot(container) {
const root = createFiberRoot(container, ConcurrentRoot);
return new ReactDOMRoot(root);
}Design Trade-offs and Optimizations
Why Concurrent Mode?
- Synchronous Rendering Limitations: Long tasks block the main thread, causing jank.
- Concurrent Advantages: Dynamic priority adjustments improve user experience.
Performance Optimizations
- Lane Model: Efficiently manages multiple tasks.
- Time Slicing: Reduces main thread pressure.
Limitations
- Increased Complexity: Developers must understand priority concepts.
- Browser Compatibility: Relies on Scheduler’s fallback mechanisms.
Source Debugging and Practice
Debugging Approach
- Clone React source:
git clone https://github.com/facebook/react.git. - Modify
ReactFiberWorkLoop.js, adding logs to trackworkLoopConcurrent. - Run a Concurrent Mode example, observing task interruptions and resumptions.
Example: Concurrent Rendering
function App() {
const [count, setCount] = useState(0);
const [isPending, startTransition] = useTransition();
return (
<>
<button onClick={() => setCount(count + 1)}>Increment</button>
<button onClick={() => startTransition(() => setCount(count + 1))}>
Transition Increment
</button>
<HeavyComponent count={count} />
</>
);
}In-Depth Analysis of Concurrent Features
Concurrent Mode is not just an asynchronous rendering framework; it offers developer-controlled concurrency through APIs like useTransition and Suspense. Below, we dive into their source implementations.
useTransition Implementation Details
Role Recap
useTransition allows marking non-urgent updates, deferring rendering via low-priority lanes to enhance interaction responsiveness.
Example
function App() {
const [isPending, startTransition] = useTransition();
const [value, setValue] = useState('');
const handleChange = (e) => {
startTransition(() => {
setValue(e.target.value); // Deferred update
});
};
return (
<div>
<input value={value} onChange={handleChange} />
{isPending ? 'Loading...' : <HeavyComponent value={value} />}
</div>
);
}Source Analysis
useTransition is defined in react-reconciler/src/ReactFiberHooks.js:
function mountTransition() {
const [isPending, setPending] = useState(false);
const hook = mountWorkInProgressHook();
const start = (callback) => {
setPending(true);
const fiber = currentlyRenderingFiber;
scheduleUpdateOnFiber(fiber, TransitionLane); // Use TransitionLane
callback();
setPending(false);
};
hook.memoizedState = [isPending, start];
return [isPending, start];
}
function updateTransition() {
const hook = updateWorkInProgressHook();
return hook.memoizedState;
}scheduleUpdateOnFiber and TransitionLane
function scheduleUpdateOnFiber(fiber, lane) {
const root = markUpdateLaneFromFiberToRoot(fiber, lane);
root.pendingLanes |= lane; // Add TransitionLane
ensureRootIsScheduled(root);
}
function ensureRootIsScheduled(root) {
const highestLane = getHighestPriorityLane(root.pendingLanes);
const priority = laneToSchedulerPriority(highestLane);
scheduleCallback(priority, () => performConcurrentWorkOnRoot(root, highestLane));
}TransitionLane(0b0000000000000000000000010000) is a low-priority lane.scheduleCallbackhands tasks to Scheduler for deferred execution.
Principle Summary
startTransitionmarks updates withTransitionLanefor low priority.isPendingreflects transition state for UI feedback.- Scheduler executes tasks in slices based on priority.
Suspense and Concurrent Mode Synergy
Role Recap
Suspense handles asynchronous component or data loading, providing a fallback UI during loading.
Example
function App() {
return (
<Suspense fallback={<div>Loading...</div>}>
<LazyComponent />
</Suspense>
);
}Source Analysis
Suspense has a Fiber type of SuspenseComponent, supporting interruption and resumption in Concurrent Mode.
beginWork Handling
function beginWork(current, workInProgress, renderLanes) {
if (workInProgress.tag === SuspenseComponent) {
return updateSuspenseComponent(current, workInProgress, renderLanes);
}
}
function updateSuspenseComponent(current, workInProgress, renderLanes) {
const nextChildren = workInProgress.pendingProps.children;
const nextState = workInProgress.memoizedState;
if (nextState !== null && !includesSomeLane(renderLanes, nextState.lane)) {
// Subtree incomplete, suspend
workInProgress.lanes = nextState.lane;
return bailoutOnAlreadyFinishedWork(current, workInProgress);
}
reconcileChildren(current, workInProgress, nextChildren);
return workInProgress.child;
}memoizedStatestores suspension state (if subtree rendering is incomplete).lanesmarks priorities for subsequent processing.
Throwing Promises
Suspense relies on child components throwing Promises:
const lazyComponent = React.lazy(() => import('./Component'));
function updateLazyComponent(current, workInProgress) {
const payload = workInProgress.pendingProps;
const resolved = payload._result;
if (resolved === null) {
throw payload._promise; // Throw Promise, trigger suspension
}
return updateFunctionComponent(current, workInProgress, resolved);
}Commit Phase Resumption
In commitRoot, suspension state is checked:
function commitRoot(root) {
const finishedWork = root.finishedWork;
if (finishedWork.lanes & SuspendedLane) {
scheduleUpdateOnFiber(root, SuspendedLane); // Reschedule
}
}Principle Summary
Suspenseinterrupts rendering by throwing Promises.- Concurrent Mode allows suspended tasks to be scheduled with low priority.
- Combined with
useTransition, it optimizes loading experiences.
In-Depth Analysis of Key Algorithms in Concurrent Mode
Lane Model’s Bit Operation Implementation
Lane Operations
function includesSomeLane(a, b) {
return (a & b) !== NoLanes; // Check for intersection
}
function mergeLanes(a, b) {
return a | b; // Merge lanes
}
function getHighestPriorityLane(lanes) {
return lanes & -lanes; // Get lowest bit (highest priority)
}lanes & -lanes: Uses two’s complement to extract the lowest bit.
Example
const lanes = 0b0000110; // DefaultLane | InputContinuousLane
const highest = getHighestPriorityLane(lanes); // 0b0000010 (InputContinuousLane)workLoopConcurrent’s Interruption Logic
function workLoopConcurrent() {
while (workInProgress !== null && !shouldYield()) {
workInProgress = performUnitOfWork(workInProgress);
}
return workInProgress === null; // Whether completed
}
function shouldYield() {
const timeElapsed = getCurrentTime() - startTime;
return timeElapsed >= yieldInterval; // Default 5ms
}shouldYieldis controlled by Scheduler, ensuring tasks stay within time slices.
bailoutOnAlreadyFinishedWork Optimization
function bailoutOnAlreadyFinishedWork(current, workInProgress) {
if (current.memoizedProps === workInProgress.pendingProps) {
return workInProgress.child; // Skip redundant rendering
}
return null;
}- Checks if
propsare unchanged, optimizing performance.
Performance Optimization Practices for Concurrent Mode
Priority Tuning
- High Priority: User interactions (e.g.,
SyncLane,InputContinuousLane). - Low Priority: Transitions (e.g.,
TransitionLane), data loading.
Example: Forcing Synchronous Updates
ReactDOM.flushSync(() => setState(newValue)); // Use SyncLaneTime Slicing Adjustments
Modify scheduler’s yieldInterval:
const yieldInterval = navigator.hardwareConcurrency > 4 ? 10 : 5; // Dynamic adjustmentAvoiding Excessive Rendering
Use useMemo and useCallback to reduce child updates:
const memoizedValue = useMemo(() => computeExpensiveValue(a), [a]);Real-World Case Studies
Case Study: Search Suggestion Box
function SearchApp() {
const [query, setQuery] = useState('');
const [results, setResults] = useState([]);
const [isPending, startTransition] = useTransition();
const handleChange = (e) => {
const value = e.target.value;
setQuery(value);
startTransition(() => {
setResults(searchAPI(value)); // Deferred update
});
};
return (
<div>
<input value={query} onChange={handleChange} />
{isPending ? 'Loading...' : <Results items={results} />}
</div>
);
}- Input updates use
SyncLane, result rendering usesTransitionLane.
Source Debugging
Add logs in ReactFiberWorkLoop.js:
function workLoopConcurrent() {
console.log('Starting work loop', workInProgress);
while (workInProgress !== null && !shouldYield()) {
workInProgress = performUnitOfWork(workInProgress);
}
}



