Synchronous Updates: Legacy Default Behavior
What you'll learn: How React treated all state updates before Concurrent React, and why this caused UI responsiveness problems.
The Old Way: Everything Blocks
Before Concurrent React (React 18's concurrent features), every state update was treated as equally urgent and synchronous. When you called setState, React would:
- Immediately start computing the entire component tree
- Block the main thread until all rendering was complete
- Commit changes to the DOM only after everything was done
This meant a heavy update (like filtering 10,000 items) had the same priority as a critical update (like typing in an input). Both would freeze your UI until complete.
The Analogy: A Single-Lane Highway
Imagine a highway with only one lane and no passing allowed. A slow-moving truck (expensive render) blocks all the sports cars (urgent updates) behind it. Everyone waits, no exceptions.
// Pre-React 18 behavior (still default without concurrent features)
setSearchQuery(newValue); // Blocks thread
setFilteredResults(heavyFilter(data, newValue)); // Still blocking
// User sees nothing until BOTH complete
Both updates execute synchronously—the browser can't respond to user input, can't paint frames, can't do anything else until React finishes.
Why This Matters Now
Understanding this legacy behavior explains why useTransition and useDeferredValue exist. They break away from this "all updates are urgent" model. Without concurrent features enabled, you're still in this synchronous world—every update blocks, every time.
Key Takeaway: Pre-concurrent React treated all state updates synchronously with equal priority, blocking the main thread until rendering completed, which caused UI freezes during expensive updates.