The article reveals that recent Nginx releases have made HTTP/1.1 keep‑alive the default configuration, eliminating the need for explicit proxy_http_version and Connection header settings, and explains how this reduces handshakes, lowers latency, and improves first‑byte response times for typical web applications.
A high‑concurrency data‑collection service quickly filled a 100 Mbps uplink because each GET request incurred a 1.68 KB TLS handshake, but switching to plain HTTP or enabling Keep‑Alive can dramatically reduce per‑request size and server load, saving up to 70% bandwidth.
A high‑concurrency service quickly saturated its 100 Mbps upstream because each GET request carried a 1.68 KB TLS handshake, but switching to plain HTTP or enabling HTTP keep‑alive can slash request size by 70 % and dramatically reduce bandwidth and CPU usage.
A high‑concurrency data collection service quickly saturated a 100 Mbps uplink because each GET request incurred a 1.27 KB TLS handshake, prompting a switch to plain HTTP and keep‑alive to cut bandwidth usage by 70% and lower server load.
A high‑concurrency service quickly maxed out a 100 Mbps uplink because each HTTPS GET request incurred a 1.68 KB payload dominated by a 1.27 KB TLS handshake, prompting a switch to plain HTTP or keep‑alive to dramatically cut bandwidth and CPU usage.
After discovering that a simple GET request consumes 1.68 KB due to the TLS handshake, the article explains the handshake’s components, calculates the resulting bandwidth demand, and demonstrates how switching to HTTP or enabling Keep‑Alive can dramatically reduce traffic and server load in high‑concurrency scenarios.
A high‑concurrency data‑collection service quickly filled a 100 Mbps uplink because each GET request incurred a 1.68 KB TLS handshake, consuming over 260 Mbps, but switching to plain HTTP or using keep‑alive can dramatically cut bandwidth and server load.
The article analyzes why a high‑concurrency data‑collection service quickly saturates a 100 Mbps uplink due to large TLS handshake payloads, demonstrates the bandwidth savings of switching to plain HTTP or using Keep‑Alive, and highlights practical considerations for secure versus performance‑optimized deployments.
The article analyzes why a high‑concurrency GET service quickly saturates a 100 Mbps uplink due to TLS handshake overhead, demonstrates bandwidth savings by switching to HTTP or using Keep‑Alive, and highlights practical considerations for secure connections.
The article explains how TLS handshakes significantly increase request size and upstream bandwidth consumption in high‑concurrency services, demonstrates the bandwidth calculations, and proposes using plain HTTP or Keep‑Alive connections to reduce overhead and server load.
By refactoring a high‑traffic Java service to use a singleton HttpClient, enable connection pooling with a custom keep‑alive strategy, and fine‑tune timeout and retry settings, the average request time dropped from 250 ms to about 80 ms, dramatically improving throughput and stability.
This article details practical optimization techniques for Apache HttpClient—including connection pooling, keep-alive, singleton client usage, proper timeout settings, and asynchronous handling—to reduce average request latency from 250 ms to about 80 ms in a ten-million-calls-per-day service.
This article explains TCP connection basics, the three‑way handshake and four‑way termination, compares short and long connections, discusses keep‑alive mechanisms, and outlines when to use each approach in network and HTTP communication.
This article explains the fundamentals of TCP connections, detailing the three‑way handshake, four‑step termination, the differences between short‑lived and persistent (long) connections, their advantages, keep‑alive mechanisms, and practical guidelines for choosing the appropriate connection type in various network scenarios.
An in‑depth comparison of HTTP Keep‑Alive (application‑layer persistent connections) and TCP Keepalive (kernel‑level health checks), covering their implementation layers, usage, configuration, timeout handling, and impact on performance, with clear diagrams and code examples to help developers master both mechanisms.
This article explains how MySQL stores NULL values and clarifies the distinct mechanisms of HTTP Keep‑Alive (application‑level long connections) versus TCP Keepalive (kernel‑level health checks), detailing their implementations, usage, and practical considerations.
This article explains how to dramatically reduce the average response time of a high‑traffic Java service from 250 ms to about 80 ms by applying HttpClient pooling, keep‑alive strategies, proper timeout settings, and idle‑connection monitoring, complete with code examples and configuration details.
The article investigates how loss of TCP SYN, SYN‑ACK, or ACK packets during the three‑way handshake affects MySQL client‑server connections, demonstrating retransmission behavior, kernel parameter tuning, and keep‑alive mechanisms through controlled iptables and tcpdump experiments.
This article details a step‑by‑step investigation of an intermittent white‑screen problem on a web application, revealing that Nginx’s use of HTTP 1.0 short connections caused mismatched static resource versions across backend servers, and explains how updating the affected server’s frontend bundle resolves the issue.
This guide explains why routing traffic through an Nginx Ingress controller can halve Kubernetes service QPS and provides step‑by‑step instructions—including switching to IPVS, tuning kernel and file‑descriptor limits, and configuring keep‑alive settings—to restore and even exceed the original performance.
This article explains how the ZhiZhi RPC framework SCF handles connection lifecycle, including establishment timing, connection pooling versus multiplexing, keep‑alive mechanisms, automatic recovery, and graceful shutdown, providing practical guidance for designing robust RPC protocols.
This article examines the practical design choices, sandbox limitations, preloading strategies, release handling, nested applications, cross‑app navigation, keep‑alive usage, shared dependencies, conflict detection, joint development, and progressive evolution of micro‑frontend solutions, offering insights and future directions.
This article explains the LRU (Least Recently Used) caching mechanism used in Vue's keep-alive component, covering its implementation, performance benefits, and practical usage scenarios.
An in‑depth look at the relationship between TCP and HTTP explains how many HTTP requests a single TCP connection can carry, covering keep‑alive, HTTP/1.0 vs 1.1 behavior, pipelining, HTTP/2 multiplexing, browser connection limits, and practical keep‑alive trade‑offs.
This tutorial walks through capturing and analyzing an HTTP request using Wireshark, detailing the environment setup, three‑way TCP handshake, key TCP header fields such as window scaling and SACK, the four‑step termination (including merged ACK/FIN), and the role of HTTP Keep‑Alive across different protocol versions.
Vue’s keep-alive component enables dynamic tab caching in B‑end applications by storing component VNodes in an internal LRU cache, preserving state across route switches, supporting include/exclude patterns, router‑meta flags, Vuex‑driven lists, and custom strategies for nested routes to prevent stale data and excess API calls.
A detailed post explains how a mis‑configured HttpClient caused thread explosion and OOM on four servers, walks through the investigation using APM metrics, clarifies keep‑alive mechanics, and presents the fix of using a singleton HttpClient with proper connection eviction.
This article explains the limits of HTTP keep-alive, compares Ajax polling and long‑polling techniques for server push, and then details how the WebSocket protocol establishes a full‑duplex connection through a handshake and data‑transfer phase.
This article examines the keep‑alive mechanism at both the HTTP and TCP layers, explains how Nginx parses and processes the Connection header, dissects Linux kernel socket options and libuv implementation, and shows how to configure and debug keep‑alive to release idle connections efficiently.
The article recounts a production OOM incident triggered by a misconfigured HttpClient evictExpiredConnections setting that caused uncontrolled thread growth, explains the underlying keep‑alive TCP behavior and NoHttpResponseException, and presents the corrective measures of using a singleton HttpClient and proper connection‑pool monitoring.
This article examines why occasional ECONNRESET errors occur in HTTP RPC keep‑alive connections, explains the underlying TCP and OS mechanisms, and compares several practical mitigation strategies—including retries, connection pre‑discard, idempotent handling, and protocol upgrades such as HTTP/2 and gRPC—to help developers choose the most reliable solution.
An in‑depth look at how browsers handle TCP connections during page loads, covering persistent connections, request limits per host, HTTP/1.1 pipelining, HTTP/2 multiplexing, and why SSL handshakes may be reused, illustrated with real‑world connection timing screenshots.
This article explains why a static‑file server can produce many TIME_WAIT connections, examines the role of the HTTP Connection and Keep‑Alive headers, and shows how different header settings affect when the server or client closes the TCP connection.
This article explains how to tune Nginx for high‑concurrency environments by adjusting OS limits, worker processes, worker connections, CPU priority, keep‑alive settings, TCP options, logging, caching, and I/O strategies to achieve optimal performance without relying on magical configurations.
