Why HTTP Still Rules: Key Features, Connection Types, and Performance Tips

HTTP Features

HTTP is a flexible and extensible transport protocol that started with a simple format and has evolved to support custom headers, various request methods, status codes, and bodies that can carry any type of data, from text to multimedia.

Because it runs over TCP/IP, HTTP inherits TCP's reliable transmission, attempting to ensure data delivery though it cannot guarantee 100% success under poor network conditions.

As an application‑layer protocol, HTTP can carry arbitrary headers and entities, making it far more versatile than specialized protocols like FTP or SSH.

HTTP follows a request‑response communication model where the client initiates a request and the server replies, aligning with traditional client/server and browser/server architectures.

It is fundamentally stateless: each request is independent, and the protocol does not require the server or client to retain any session information between requests.

Other Notable Characteristics

Additional features include cacheability, compressibility, support for range requests, authentication, and internationalization, all stemming from its extensible design.

Summary of Core Features

Flexible extensibility allows arbitrary header fields.

Reliable transmission built on TCP/IP.

Application‑layer protocol with broad functionality.

Request‑response model defines clear client‑server roles.

Statelessness means each request is independent.

HTTP Connection Management

Early HTTP (0.9/1.0) used short connections: a TCP connection was opened for each request and closed immediately after the response, incurring high overhead due to TCP's three‑way handshake and four‑way teardown.

Long connections (persistent connections) reuse a single TCP connection for multiple HTTP requests, reducing the per‑request overhead and improving overall throughput.

In HTTP/1.1, connections are persistent by default. The server signals this with the header Connection: keep-alive. Clients can explicitly request persistence with the same header, or request closure with Connection: close.

Servers may enforce policies such as keepalive_timeout or keepalive_requests (e.g., in Nginx) to limit idle or excessive long connections.

Head‑of‑Line Blocking

Because HTTP processes requests in a FIFO order, a slow request at the front of the queue blocks subsequent requests, leading to performance degradation.

Performance Optimizations

To mitigate head‑of‑line blocking, browsers open multiple concurrent connections to the same host (historically limited to 2, now often 6‑8) and may employ domain sharding—using multiple hostnames pointing to the same server—to increase parallelism.

Connection Management Summary

Early HTTP used short connections, which are inefficient.

HTTP/1.1 enables long (persistent) connections, improving efficiency.

Servers indicate persistence with Connection: keep-alive.

Explicit Connection: close signals an upcoming closure.

Excessive long connections consume server resources; servers use timeout or request‑count limits to close idle connections.

Head‑of‑line blocking can be alleviated with concurrent connections and domain sharding.

Reference

透视HTTP协议