What Is HTTP/2?

Higher Robustness

HTTP/1.1 keeps requests and responses in text format. Text is expressed in diversified modes and used in many scenarios, but is not robust enough. HTTP/2 uses the binary format. Only combinations of 0 and 1 are available in HTTP/2 requests and responses. Binary transmission makes protocol parsing easy and robust.

Higher Performance

HTTP connections automatically tune themselves over time, which initially limits the maximum connection speed. If data is successfully transmitted, the transmission speed increases over time. This tuning mechanism is called TCP slow start. This mechanism makes bursty and short-term HTTP connections inefficient. HTTP/2 uses multiplexing to allow all data streams to be transmitted over the same TCP connection, effectively utilizing TCP connections and enabling high bandwidth to truly improve HTTP performance.

HTTP/2 adds the binary framing layer between the application layer and the transport layer, which overcomes performance limitations of HTTP/1.1, improves transmission performance, and achieves low latency and high throughput.

Lower Network Overhead

HTTP/2 uses the HPACK algorithm to compress header fields of each request or response, reducing the network overhead. The HPACK algorithm can reduce the size of header fields to be transferred. Two communication parties establish and maintain an indexed list, which uses index values to indicate previously transferred header fields. Then, Huffman coding is used to compress the data. This avoids transmission of repeated header fields and reduces the size of data to be transmitted.

Binary Framing

The core of all performance enhancements of HTTP/2 is the new binary framing layer, as shown in the following figure. The binary framing layer is the foundation that enables all other function and performance optimizations provided by HTTP/2, and defines how HTTP messages are encapsulated and transferred between the client and server.

Binary framing layer

HTTP/2 does not change application semantics of HTTP, and still uses the HTTP request methods, status codes, and header fields. It mainly modifies the way how data is formatted and transmitted. Unlike the newline delimited plaintext HTTP/1.1 protocol, HTTP/2 splits information to be transferred into smaller messages and frames, each of which is encoded in binary format. These frames correspond to messages in specific data streams and are multiplexed within a TCP connection.

Stream Prioritization

After an HTTP message is split into many individual frames, frames in multiple data streams can be multiplexed. The order in which the frames are interleaved and sent both by the client and server becomes a critical factor for determining performance. HTTP/2 allows each data stream to have an associated weight and dependency. The combination of data stream dependencies and weights clearly specifies resource prioritization, which is a critical feature for improving browsing performance. HTTP/2 also allows the client to update resource priorities at any time. In this way, we can change dependencies and reallocate weights in response to user interactions and other signals, enabling further optimizations in browsers.

Header Compression

Each HTTP request or response carries headers which describe resource attributes. In HTTP/1.1, message headers are sent as plain text. If HTTP cookies are used in message headers, hundreds to thousands bytes need to be transferred repeatedly each time, which is resource-wasting.

HTTP/2 uses the HPACK algorithm to compress header fields. This algorithm encodes the transferred header fields, thereby reducing the size of the header fields. In addition, it requires that both the client and server maintain an indexed list of previously transferred header fields. Subsequently, when the index values of these header fields are transferred, the peer end can obtain the data in header fields according to the index values.

Multiplexing

Multiplexing allows the client and server to send multiple request and response messages through one HTTP/2 connection at the same time. Multiplexing implements transfer of multiple streams in parallel without requiring multiple TCP connections. In HTTP/2, the frame is the smallest unit of communication. Frames correspond to messages in logical streams, and are interleaved bidirectionally over the same TCP connection in parallel.

Based on the binary framing layer, HTTP/2 allows the client and server to send requests and responses at the same time through the shared TCP connection. HTTP/2 allows the client and server to split an HTTP message into independent frames without breaking the semantics of the message, interleave them, and then reassemble them at the other end based on stream identifiers and headers. Multiplexing resolves the head-of-line blocking problem in earlier HTTP versions and improves transmission performance.

Server Push

Another powerful new feature of HTTP/2 is the ability of the HTTP/2 server to send multiple responses for a single client request. The server can push resources to a client without requiring the client to request each one explicitly. The server returns multiple responses in advance based on the request from the client and pushes additional resources to the client. For example, as shown in the following figure, when the client requests for stream 1, the server pushes stream 2 and stream 4 in addition to stream 1.

HTTP/2 server push

Server push is a mechanism for sending data before a client sends a request. In HTTP/2, the server can send multiple responses for a request from a client. If a request is sent by your home page, the server may push the home page content, logo, and style sheet because the server infers that the client will use them. Server push not only eliminates redundant data transmission steps, but also increases the page response speed and improves user experience.