The article presents a reproducible Nginx performance‑tuning workflow that starts with defining a baseline and acceptance criteria, measures CPU, file‑descriptor, upstream and disk limits, then incrementally adjusts worker settings, systemd limits, keepalive, buffering and compression, while using gray‑scale deployment and safe rollback.
The article explains why the default 7200‑second TCP KeepAlive idle time causes RSTs in cloud environments, demonstrates Netty configuration for finer‑grained keepalive settings, shares real‑world cloud‑networking failures, and recommends adjusting Linux kernel parameters as a reliable solution.
A single missing keepalive setting in Nginx caused a massive P0 outage during a sales promotion, and the article walks through five real incidents—covering logging, WebSocket timeouts, Docker worker counts, reload pitfalls, and SSL expiry—offering concrete configuration fixes and preventive best practices.
By establishing baselines, methodically profiling logs, and applying layered tweaks—such as keepalive connections, gzip compression, proxy caching, worker tuning, HTTP/2, kernel parameters, and backend caching—this guide demonstrates how to reduce Nginx’s total response time from 500 ms to under 50 ms with measurable results.
This article details a systematic performance test of Nginx 1.29.x’s new HTTP/2 upstream support, comparing HTTP/1.1, HTTP/2 with keep‑alive, and HTTP/1.0 baselines across various payload sizes, connection‑pool settings, and large‑header scenarios to determine when protocol upgrades yield real throughput or latency gains.
This article explains the concepts, purposes, and mechanisms of TCP keepalive and HTTP keepalive, detailing kernel parameters, timing intervals, and how they prevent half‑open connections, along with practical commands, configuration tips for servers like Nginx and Gunicorn, and the interaction between the two layers.
The article shows that Spring Boot itself does not limit concurrency; the true ceiling is set by Linux TCP parameters, Tomcat's acceptCount and maxConnections, its thread‑pool strategy, and KeepAlive settings, and it walks through source code, default values, and practical experiments to reveal where requests are blocked.
This article reviews recent React developments—including the React 19.2 release, new Activity and useEffectEvent APIs, the stable 1.0 release of babel‑plugin‑react‑compiler—and explains how automatic compiler‑based optimizations replace manual memo, useCallback, and useMemo patterns, while also covering KeepAlive challenges and code examples.
This article explains why traditional asynchronous requests often fail during page unload, and demonstrates two modern browser APIs—navigator.sendBeacon and fetch with keepalive:true—that reliably transmit small data without blocking the user experience.
This guide explains how to use the ~/.ssh/config file to replace long SSH commands with short aliases, organize host blocks, enable bastion jumps, reuse connections, and keep sessions alive, dramatically improving productivity for managing dozens or hundreds of servers.
Explain that “keepalive” is a concept used in both NGINX and HTTP protocol but with different meanings. In HTTP, keep‑alive (or persistent connection) is a header that allows a TCP connection to be reused for multiple requests, reducing latency. In NGINX, keepalive refers to the connection‑pool settings for upstream servers, controlling how many persistent connections are kept and their timeout.
This article presents advanced WebSocket testing techniques—including asynchronous connection creation, result statistics, price verification, latency measurement, TPS modeling—and demonstrates a Netty‑WebSocket subscription test for 10,000 users plus Java‑ and Netty‑based keepalive implementations for high‑concurrency scenarios.
This article explains how TCP connection setup, slow‑start, delayed acknowledgments, the Nagle algorithm, TIME_WAIT and file‑descriptor limits affect HTTP performance, and shows how to tune Nginx and Linux keep‑alive settings to achieve faster, more reliable web traffic.
Riverpod annotations streamline Flutter state management by using build_runner to generate provider code, where @riverpod on functions creates Provider, FutureProvider, or StreamProvider based on return type, on classes creates NotifierProvider, supports Family‑pattern parameters, keepAlive, dependencies, and produces helper classes for auto‑dispose and scoped overrides.
This article provides a comprehensive guide to TCP connection states, common Linux commands for monitoring them, detailed explanations of each state transition, three‑way handshake, four‑way termination, flag meanings, keep‑alive mechanisms, and practical sysctl tuning to troubleshoot network issues.
This article provides a comprehensive guide to TCP connection states, Linux commands for monitoring them, the three‑way handshake, four‑way termination, flag meanings, common pitfalls like SYN floods, and practical keep‑alive and sysctl tuning techniques for reliable network troubleshooting.
This article explains TCP connection states, the three-way handshake and four-way termination processes, provides essential Linux commands for monitoring connections, and offers practical tips for diagnosing network issues, handling SYN floods, TIME_WAIT problems, and implementing keepalive mechanisms to maintain reliable communication.
This guide explains how Spring Boot 3.2+ leverages JDK 21 virtual threads, demonstrates common pitfalls in non‑web applications—especially daemon thread termination—and shows how to enable keep‑alive configuration to ensure your tasks keep running, complete with code examples and performance insights.
This guide explains why SSH connections may close due to TCP timeouts, describes the relevant kernel parameters, and provides step‑by‑step client and server configuration instructions for Linux and Windows to keep SSH sessions active without interruption.
Learn why SSH connections drop due to TCP timeout settings and follow step‑by‑step Linux, Windows (PuTTY), and server‑side configurations—including tcp_keepalive and ServerAlive options—to keep remote sessions active and avoid idle‑disconnects for developers.
This article walks through a real‑world performance overhaul of Apache HttpClient—using a singleton client, connection pooling, a custom keep‑alive strategy, timeout tuning, and idle‑connection monitoring—to reduce average request time from 250 ms to about 80 ms for a high‑throughput service.
This article explains why browsers cancel pending requests during navigation, the risks of lost data, and demonstrates reliable solutions using JavaScript—first by awaiting fetch, then leveraging the fetch keepalive option—to guarantee logs reach the server without delaying page loads.
This article details how to dramatically improve the performance of a million‑level QPS Java service by reusing a singleton HttpClient, enabling keep‑alive connection pooling, and handling responses efficiently, cutting average request time from 250 ms to about 80 ms.
This article explains how to dramatically improve the performance of a high‑traffic Java service by reusing a singleton HttpClient, enabling connection pooling and keep‑alive, tuning timeout and retry settings, and adding an idle‑connection monitor to reduce average request latency from 250 ms to about 80 ms.
This guide walks through practical Nginx configurations—including serving multiple domains, setting up basic authentication, enabling directory listings, defining default sites, blocking unwanted IP access, handling verification files, configuring upstream reverse proxies, enabling keepalive, and redirecting 404 errors—to help operators and developers optimize their web server setups.
TCP connections can be either short-lived, closing after a single request‑response cycle, or long-lived, staying open for multiple exchanges; this article explains their handshake processes, advantages, drawbacks, typical use cases, reasons long connections drop, and practical strategies such as keepalive and reconnection to maintain reliability.
This article explains how TCP/IP heartbeat and retransmission mechanisms work, shows how to configure Windows keep‑alive parameters, demonstrates using libwebsockets’ keep‑alive settings, and provides non‑blocking socket + select code to detect connection failures and enforce a 60‑second reconnection window for video conferencing applications.
This article explains how unstable network conditions cause TCP disconnections in video conferencing, then details TCP/IP heartbeat mechanisms, ACK handling, keepalive parameter tuning, libwebsockets integration, packet loss retransmission, and non‑blocking socket connect timeout control with code examples.
Facing frequent packet loss and network jitter that disrupts video conferences, this article examines TCP/IP stack heartbeat and retransmission mechanisms, demonstrates how to configure Windows keepalive parameters, and provides code examples for custom socket options and non‑blocking connect timeouts to maintain session continuity within 60 seconds.
This tutorial explains why SSH connections close, shows how to configure both client and server settings—including creating the .ssh/config file, setting ServerAliveInterval, ServerAliveCountMax, and adjusting /etc/ssh/sshd_config—to keep sessions alive until you intentionally close the terminal.
This tutorial explains why SSH connections close, shows how to configure both client and server settings to keep sessions alive, and discusses why permanently disabling timeouts may not be advisable, especially on cloud platforms.
This article explains the concepts, purposes, and inner workings of TCP keepalive and HTTP keepalive, compares their roles in maintaining network connections, and provides practical guidance on configuring related parameters and handling socket lifecycles in server environments.
This article explains the TCP keepalive mechanism, its purpose, default parameters, how to configure and verify it on Linux, its drawbacks, and the distinction between TCP keepalive and HTTP Keep-Alive, providing practical code examples and network analysis steps.
This guide explains TCP connection states, essential Linux commands, three‑way handshake, four‑way termination, simultaneous open/close, flag meanings, common error codes, and keep‑alive techniques to help you troubleshoot and secure network services effectively.
Unplugging a network cable does not immediately terminate a TCP connection; the kernel’s socket state remains ESTABLISHED, and the connection’s fate depends on data transmission, retransmission limits, TCP keepalive settings, and whether either side detects a failure.
The article documents a systematic investigation of why an Apache HttpClient‑based utility class fails to reuse connections, reproduces the problem with a test server and client, analyzes Tomcat's default maxKeepAliveRequests limit of 100, and provides recommendations for configuration.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived HTTP/1.1 keep‑alive connections between client and Nginx and between Nginx and upstream servers, covering required directives, upstream and location settings, performance implications for high QPS workloads, and advanced WebSocket handling.
This article explains how to configure Nginx as a reverse proxy to maintain long‑lived client and server connections, optimize keep‑alive parameters, and avoid connection churn in high‑QPS scenarios, providing practical code examples and advanced tuning tips.
This article explains how the testWhileIdle and keepAlive parameters of the Druid connection pool differ in their idle‑connection validation behavior, demonstrates the effects with a Java test program, and recommends using keepAlive for reliable Dble connectivity.
Version v0.0.7 introduces a configurable keepalive timeout for the TCP RPC server, automatically closing idle client connections after a set period, reducing resource usage and preventing memory leaks while allowing the client to transparently reconnect when needed.
This guide explains Android keep‑alive strategies—including boot‑completed receivers, account‑sync adapters, JobScheduler jobs, and foreground services—while also covering device‑specific settings for enabling or disabling background execution on manufacturers such as Huawei.
This guide explains how to optimize Linux kernel parameters and Nginx settings—such as file descriptor limits, TCP queue lengths, temporary ports, worker processes, KeepAlive, and log buffering—to significantly improve server performance and handle high traffic loads.
This article explains why TCP KeepAlive is needed, how it differs from HTTP Keep-Alive, and provides practical Linux kernel and Nginx configuration steps to prevent session timeouts in load‑balancing scenarios such as LVS and F5 devices.
This article explains the differences between HTTP/1.1 and HTTP/1.0 keep‑alive, the TCP keepalive mechanism and its kernel parameters, how to configure them in applications, and how Nginx implements and manages keepalive for client and upstream connections with detailed code examples.
This article experimentally explores Nginx's keepalive settings—HTTP keepalive_timeout, proxy_read_timeout, and TCP so_keepalive—showing how different browsers, upstream delays, and TCP probes affect connection lifetimes and what practical steps administrators can take to troubleshoot unexpected disconnects.
This article explains TCP state definitions, Linux commands for monitoring connections, the three‑way handshake, four‑way termination, common pitfalls like SYN‑Flood attacks, and practical tips such as keepalive configuration to diagnose and resolve network or socket problems.
This guide walks through practical Nginx configurations—including serving multiple domains from one server block, per‑site root setups, basic authentication, directory listing tweaks, default site handling, IP blocking, custom verification files, upstream reverse proxy nuances, keepalive tuning, and automatic 404 redirection—providing ready‑to‑use code snippets for each scenario.
This article presents a comprehensive overview of MySQL high‑availability solutions, covering classic HA architectures, synchronization tools such as MHA, MMM, HA‑JDBC, Galera and Group Replication, and shares NetEase's practical implementations using distributed databases and keepalive‑based failover.
This article details a real‑world Nginx performance tuning case where long‑running client requests caused timeouts, describing how adjusting keepalive settings, TCP reuse parameters, and upstream proxy timeouts eliminated the delays and stabilized the service for millions of calls.
This article explains the TCP KeepAlive mechanism, why load balancers like LVS and F5 drop idle connections after 90 seconds, how to configure Linux kernel and socket options, and the correct way to enable TCP KeepAlive in Nginx to prevent premature disconnects.
