Daily Insight: What Are the Differences Between HTTP 1.0, 1.1, 2.0, and 3.0?

Hello everyone, this is the Programming Cookbook. Today’s daily insight is about computer networking knowledge: What are the differences between HTTP 1.0, 1.1, 2.0, and 3.0?

Table of Contents

  • What Are the Differences Between HTTP 1.0, 1.1, 2.0, and 3.0?
    • 1. HTTP 1.0
    • 2. HTTP 1.1
    • 3. HTTP 2.0
    • 4. HTTP 3.0
    • Summary Comparison
    • Conclusion

HTTP Protocol

What Are the Differences Between HTTP 1.0, 1.1, 2.0, and 3.0?

HTTP (HyperText Transfer Protocol) is the core protocol for Web communication, which has evolved through multiple versions to enhance performance, security, and reliability. Below is the evolution and development process of HTTP 1.0, 1.1, 2.0, and 3.0:

1. HTTP 1.0

Release Date: 1996 (RFC 1945)

HTTP 1.0 is the first official version of HTTP, with the following main features:

  1. Stateless and Connectionless: Each request-response requires a separate TCP connection, and the connection is closed after the request is completed, resulting in significant overhead.
  2. No Persistent Connection by Default: Each request requires a TCP three-way handshake, increasing latency.
  3. Request/Response Model:
  • Uses plain text format, employing basic methods such as <span>GET</span>, <span>POST</span>, <span>HEAD</span>, etc.
  • The server must wait for the previous request to complete before processing the next request (Head-of-Line Blocking issue).
  • Limited Cache Control:
    • Cache control mainly relies on the <span>Expires</span> header field, which specifies the absolute expiration time of resources, for example: 
      Expires: Wed, 20 Mar 2025 12:00:00 GMT
    • Clients often cannot effectively determine whether resources need to be re-requested.

    Disadvantages:

    • Low connection efficiency, as a new TCP connection must be established for each request.
    • Cannot perform parallel requests, affecting performance.
    • The server side lacks caching mechanisms, resulting in low bandwidth utilization.

    2. HTTP 1.1

    Release Date: 1997 (RFC 2068, later updated to RFC 2616)

    HTTP 1.1 is a significant milestone in Web development, addressing several performance issues of HTTP 1.0:

    1. Supports Persistent Connections:
    • By default, TCP long connections are enabled (<span>Connection: keep-alive</span>).
    • Allows multiple requests to be transmitted over the same TCP connection, reducing the overhead of establishing connections.
  • Supports Pipelining:
    • Allows clients to send multiple requests in parallel (but the server must still respond in order).
    • The Head-of-Line Blocking issue still exists, as a slow request can block subsequent requests.
  • Increased Caching Mechanism:
    • Introduces the <span>Cache-Control</span> field, supporting <span>max-age</span> (how many seconds the resource is valid), <span>no-cache</span> (even if the client has a local cached copy, it cannot be used directly and must request the server to check for updates), <span>no-store</span> (prohibits caching, always requests the latest data), etc., to control caching behavior.
  • Chunked Transfer Encoding:
    • Allows the server to send data in chunks, suitable for large file transfers.
  • Supports the <span>Host</span> field:
    • HTTP 1.0 did not have a <span>Host</span> field, which meant one IP could only serve one website.
    • HTTP 1.1 supports <span>Host</span> field for virtual hosting, allowing one server to host multiple websites. For example, example.com and another.com can share the same IP address and be distinguished by the Host field in HTTP requests.

    Disadvantages:

    • Head-of-Line Blocking issue still exists (although pipelined requests can improve parallelism, the server still processes requests in order).
    • Complex TCP handshake and slow start mechanisms still affect performance.

    3. HTTP 2.0

    Release Date: 2015 (RFC 7540)

    HTTP 2.0 is optimized based on the SPDY protocol, introducing binary framing, multiplexing, header compression, and server push, significantly enhancing performance:

    1. Binary Framing:
    • HTTP 1.x used plain text parsing, meaning each part of requests and responses (such as request lines, headers, and bodies) was readable strings. HTTP 2.0 switched to binary format, breaking data into small frames for transmission, making parsing more efficient,
    • Data is encapsulated into frames, improving parsing and transmission efficiency.
  • Multiplexing:
    • Multiple requests can be processed in parallel over a single TCP connection, with each request identified by a different stream ID.
    • Solves the Head-of-Line Blocking issue of HTTP 1.1, avoiding the overhead of serial processing of multiple requests.
  • Header Compression:
    • Uses the HPACK algorithm for header compression, reducing redundant data (duplicate header fields) and improving bandwidth utilization.
  • Server Push:
    • The server can proactively push resources that the client may need (such as CSS, JS), reducing the number of additional requests.
  • Priority and Flow Control:
    • Allows clients to specify the priority of requests, enabling critical resources to load first.

    Disadvantages:

    • Head-of-Line Blocking still exists at the TCP level:
      • HTTP 2.0 itself solves the application layer’s Head-of-Line Blocking, but since all requests still share one TCP connection, if TCP packet loss occurs, all requests on the entire connection will be affected.

    HTTP/2 is still based on the TCP protocol, which is a stream-oriented protocol that requires data to arrive in order. If TCP packets<span> are lost or out of order</span>, the TCP layer will wait for the lost <span>packets to be retransmitted</span>, causing subsequent data to be blocked. HTTP/3 completely resolves the Head-of-Line Blocking issue at the TCP layer by using the QUIC protocol: based on UDP, it no longer relies on TCP. Each stream is transmitted independently, and lost packets only affect the corresponding stream, without blocking other streams.

    4. HTTP 3.0

    Release Date: 2022 (RFC 9114)

    HTTP 3.0 is based on the QUIC protocol, which completely resolves the Head-of-Line Blocking issue of TCP, providing faster and more stable transmission:

    1. QUIC protocol based on UDP:
    • HTTP 3.0 no longer relies on TCP, switching to UDP【QUIC (Quick UDP Internet Connections)】.
    • Resolves the Head-of-Line Blocking issue of TCP, so that even if a request is lost, it does not affect other requests.
  • 0-RTT Handshake:
    • The QUIC protocol based on UDP allows for 0-RTT connection establishment, reducing the latency of the first request.
    • Previous TCP+TLS typically required 1-3 round trips (RTT) to establish a connection, while QUIC can send data on the first request.
  • Built-in TLS 1.3:
    • HTTP 3.0 mandates the use of TLS 1.3 for encrypted communication, enhancing security.
    • Since QUIC integrates TLS encryption, it reduces the additional TLS handshake latency.
  • Improved Flow Control:
    • Streams in QUIC are independent, so packet loss in one stream does not affect data transmission in other streams, improving concurrent performance.
  • Faster Reconnection:
    • QUIC supports connection migration, allowing connections to remain uninterrupted even if the device’s IP changes (e.g., switching from WiFi to 4G), while TCP requires re-establishing the connection.

    Disadvantages:

    • QUIC is based on UDP, which may not be compatible with some older network devices or firewalls.
    • Increased complexity on the server-side implementation, requiring support for the QUIC protocol stack.
    • Higher CPU usage, as QUIC needs to handle packet loss, flow control, etc., while TCP optimizations are already very mature.

    Summary Comparison

    Version Main Features Connection Reuse Head-of-Line Blocking Transmission Method Encryption
    HTTP 1.0 Establishes a new connection for each request ❌ Severe Plain text ❌
    HTTP 1.1 Persistent connections, pipelining ❌ Still exists Plain text ❌
    HTTP 2.0 Binary framing, multiplexing, server push, header compression ✅ Still exists at the TCP level Binary ✅ (optional)
    HTTP 3.0 Based on QUIC, UDP transmission, no Head-of-Line Blocking, TLS 1.3, 0-RTT ✅ ❌ (completely resolved) Binary ✅ (mandatory TLS 1.3)

    Conclusion

    • HTTP 1.0 → 1.1: Introduced persistent connections and cache control, improving efficiency.
    • HTTP 1.1 → 2.0: Binary frames, multiplexing, header compression, etc., solving application layer Head-of-Line Blocking.
    • HTTP 2.0 → 3.0: Based on QUIC (UDP), completely resolving TCP Head-of-Line Blocking and improving transmission speed.

    HTTP 3.0 has become a trend for the future development of the Web, especially suitable for high-latency, unstable network environments (such as mobile devices), significantly enhancing the Web experience.

    Complete HTTP Knowledge

    The Computer Networking Cookbook has been mostly updated, welcome to click the image below to enter the collection directory.

    Daily Insight: What Are the Differences Between HTTP 1.0, 1.1, 2.0, and 3.0?

    Discussion GroupDaily Insight: What Are the Differences Between HTTP 1.0, 1.1, 2.0, and 3.0?

    Leave a Comment