Introduction to React Concurrent Mode
React Concurrent Mode, introduced in React 18, is a significant feature enabled by a scheduler and interruptible work units.
Principles of Concurrent Mode
Before React 18, React used a synchronous update mechanism where every state change triggered an immediate full re-render, potentially causing the UI to become unresponsive during complex updates. Concurrent Mode addresses this by allowing React to perform rendering work during idle periods, preventing UI blocking.
Scheduler
The scheduler is the core of Concurrent Mode, determining when rendering tasks are executed. It interleaves rendering work between user interactions or animation frames to ensure a smooth user experience.
Interruptible Work Units
React breaks rendering tasks into smaller, interruptible units. If a higher-priority task arises during rendering, the current unit can be paused and resumed later.
Key Concepts
- Suspense: A special component that handles asynchronous boundaries, displaying a loading indicator while child components load or compute.
- React.lazy(): A higher-order component for dynamically loading components, often used with Suspense for on-demand loading.
- useTransition(): A Hook for managing rendering during transitions, lowering the priority of non-interactive updates to optimize performance.
import React, { lazy, Suspense, useTransition } from 'react';
const AsyncComponent = lazy(() => import('./AsyncComponent'));
function App() {
const [startTransition, isPending] = useTransition();
function handleClick() {
startTransition(() => {
// Updates here execute at lower priority
// e.g., loading new data or updating state
});
}
return (
<div>
<button onClick={handleClick}>Start Transition</button>
<Suspense fallback={<div>Loading...</div>}>
<AsyncComponent />
</Suspense>
</div>
);
}
export default App;In this example, AsyncComponent is dynamically loaded using React.lazy() within a Suspense boundary. The useTransition Hook manages rendering during transitions, executing updates at a lower priority to avoid blocking the main thread.
To deeply understand Concurrent Mode, familiarize yourself with:
- Priority: React’s priority system determines which updates are processed first.
- Concurrent Context: A context created in Concurrent Mode to pass rendering phase information.
- Error Boundaries: Their behavior may differ in Concurrent Mode due to interrupted and resumed rendering.
Enabling Concurrent Mode in Components
Updating React Version
Ensure your project uses React 18.0 or higher, as Concurrent Mode’s key features were introduced in this version.
Using createRoot
In React 18, you no longer need a concurrent flag on the root component. Instead, use ReactDOM.createRoot or ReactDOM.hydrateRoot to replace ReactDOM.render or ReactDOM.hydrate, creating a root that supports Concurrent Mode.
import React from 'react';
import ReactDOM from 'react-dom/client';
const root = ReactDOM.createRoot(document.getElementById('root'));
root.render(<App />);Using Suspense Boundaries
Suspense is a critical part of Concurrent Mode, defining asynchronous boundaries. It displays a loading indicator while child components load or compute, allowing other UI parts to render.
import React, { lazy, Suspense } from 'react';
const AsyncComponent = lazy(() => import('./AsyncComponent'));
function App() {
return (
<div>
<Suspense fallback={<div>Loading...</div>}>
<AsyncComponent />
</Suspense>
</div>
);
}Using React.lazy and SuspenseList
React.lazy enables dynamic component loading, typically used with Suspense. SuspenseList provides finer control, allowing smooth transitions between a group of asynchronous components.
import React, { lazy, Suspense, SuspenseList } from 'react';
const ComponentA = lazy(() => import('./ComponentA'));
const ComponentB = lazy(() => import('./ComponentB'));
function App() {
return (
<SuspenseList revealOrder="together">
<Suspense fallback={<div>Loading A...</div>}>
<ComponentA />
</Suspense>
<Suspense fallback={<div>Loading B...</div>}>
<ComponentB />
</Suspense>
</SuspenseList>
);
}Using useTransition and useDeferredValue
The useTransition and useDeferredValue Hooks allow prioritizing updates, enhancing performance and user experience.
import React, { useState, useTransition } from 'react';
function App() {
const [data, setData] = useState(null);
const [startTransition, isPending] = useTransition();
function fetchData() {
// Simulate async data loading
return new Promise(resolve => setTimeout(() => resolve({}), 1000));
}
async function handleClick() {
startTransition(async () => {
const newData = await fetchData();
setData(newData);
});
}
return (
<div>
<button onClick={handleClick}>Fetch Data</button>
{isPending ? <div>Loading...</div> : data && <div>Data: {JSON.stringify(data)}</div>}
</div>
);
}Using SuspenseList
SuspenseList is a React 18 component for fine-grained control over the loading and rendering of asynchronous components. It defines how a group of components displays loading states and transitions to final content.
Basic Usage of SuspenseList
The SuspenseList component accepts a revealOrder prop, which determines the order in which components load and display. Possible values are:
'together': All components must finish loading before displaying together.'forwards': Components load and display in their listed order.'backwards': The last component loads first, displaying in reverse order.
SuspenseList Code Example
Suppose we have two asynchronously loaded components, AsyncComponentA and AsyncComponentB, and want to display a global loading state before smoothly transitioning to the final content.
import React, { lazy, Suspense, SuspenseList } from 'react';
const AsyncComponentA = lazy(() => import('./AsyncComponentA'));
const AsyncComponentB = lazy(() => import('./AsyncComponentB'));
function App() {
return (
<div>
<SuspenseList revealOrder="forwards">
<Suspense fallback={<div>Loading A...</div>}>
<AsyncComponentA />
</Suspense>
<Suspense fallback={<div>Loading B...</div>}>
<AsyncComponentB />
</Suspense>
</SuspenseList>
</div>
);
}Step-by-Step Analysis
Creating Asynchronous Components
First, define two asynchronously loaded components, AsyncComponentA and AsyncComponentB, using React.lazy for dynamic loading on first access.
// AsyncComponentA.js
const AsyncComponentA = lazy(() => import('./AsyncComponentA'));
// AsyncComponentB.js
const AsyncComponentB = lazy(() => import('./AsyncComponentB'));Using Suspense
Wrap each asynchronous component in a Suspense component, with the fallback prop defining the content displayed during loading.
<Suspense fallback={<div>Loading A...</div>}>
<AsyncComponentA />
</Suspense>Using SuspenseList
Wrap all Suspense components in a SuspenseList, setting the revealOrder prop. In this example, 'forwards' ensures components load and display in their listed order.
<SuspenseList revealOrder="forwards">
{/* Suspense components go here */}
</SuspenseList>Advanced Usage of SuspenseList
Custom Transition Effects
SuspenseList can work with CSS or animation libraries for custom transition effects, using properties like transition or animation for smooth loading state changes.
/* CSS for transition */
.suspense-loading-enter {
opacity: 0;
}
.suspense-loading-enter-active {
opacity: 1;
transition: opacity 0.5s ease-out;
}// In your component
<div className={`suspense-loading ${isLoaded ? 'suspense-loading-enter-active' : ''}`}>
Loading...
</div>Handling Error Boundaries
When using SuspenseList, account for error handling. If any asynchronous component fails to load, SuspenseList halts rendering the entire list. Wrap SuspenseList in an error boundary or use React.ErrorBoundary.
<ErrorBoundary>
<SuspenseList revealOrder="forwards">
{/* Suspense components go here */}
</SuspenseList>
</ErrorBoundary>Performance Optimization
SuspenseList significantly improves performance and user experience, especially for pages with multiple asynchronous components. To maximize performance:
- Minimize Asynchronous Components: Too many increase scheduling and rendering complexity; consolidate or optimize where possible.
- Optimize Loading Times: Use code splitting, caching, and preloading to reduce component load times.
- Choose Appropriate revealOrder: Balance loading speed and smooth transitions with the right
revealOrder.
SuspenseList is a powerful tool for controlling asynchronous component loading and rendering in React. Proper configuration enhances performance and user experience but adds complexity, so weigh the trade-offs to ensure optimal results.



