TCP Head-of-Line Blocking in HTTP/2
You'll learn how packet loss at the TCP layer can still stall all HTTP/2 streams on a connection, despite HTTP/2's multiplexing.
The Paradox of HTTP/2 Multiplexing
HTTP/2 solved HTTP-level head-of-line blocking through multiplexing—multiple streams share one TCP connection without waiting for each other. However, there's a hidden bottleneck lurking beneath: TCP itself.
How TCP Head-of-Line Blocking Works
TCP guarantees ordered delivery of packets. When a single TCP packet is lost in transit, TCP must wait for that packet to be retransmitted and received before delivering any subsequent packets—even if those packets belong to completely different HTTP/2 streams.
An Analogy
Imagine a train carrying multiple cargo containers (HTTP/2 streams) on connected railcars (TCP). If one railcar derails, the entire train stops until that car is fixed and reattached—even though the containers behind it are perfectly fine and ready to be delivered.
Why This Matters for HTTP/2
All your multiplexed streams flow over a single TCP connection. If packets for Stream A are lost, Streams B, C, and D—which have nothing to do with Stream A—are also blocked from delivering their data. The TCP layer holds back everything until the missing packet arrives.
This is especially problematic on high-latency or lossy networks (mobile, congested WiFi). HTTP/1.1 with multiple connections could sometimes perform better because packet loss on one connection didn't block others.
The HTTP/3 Solution
This limitation is precisely why HTTP/3 moved to QUIC (UDP-based), which implements stream-level packet recovery instead of connection-level blocking.
Key Takeaway: While HTTP/2 eliminates application-level head-of-line blocking through multiplexing, TCP's ordered delivery guarantee creates transport-level blocking where packet loss on one stream stalls all streams sharing the connection.