Tagged articles
TIME_WAIT
39 articles · Page 1 of 1
This article provides a comprehensive guide to TCP three-way handshake, four-way teardown, and troubleshooting common connection failures using Linux tools like ss, tcpdump, and curl, emphasizing evidence-based diagnosis over theoretical concepts.
Connection RefusedLinux networkingMTU
0 likes · 27 min read

A comprehensive guide to Linux network fault diagnosis using tcpdump, netstat, and ss, covering TCP state analysis, packet capture filters, kernel parameter tuning, and real-world case studies for TIME_WAIT, SYN_RECV, CLOSE_WAIT, and latency issues.
Linux networkingSYN FloodTIME_WAIT
0 likes · 59 min read

The article explains that 'Cannot assign requested address' errors under high concurrency stem from slow TIME_WAIT recycling, not port exhaustion, and shows how enabling tcp_tw_reuse and tcp_timestamps instantly solves it without a restart, while warning against the deprecated tcp_tw_recycle.
Linux kernelTCP tuningTIME_WAIT
0 likes · 5 min read

This article provides a detailed, packet‑by‑packet walkthrough of TCP's three‑way handshake and four‑step connection termination, explains the TCP header fields, explores TIME_WAIT issues, compares BBR and Cubic congestion control, and offers practical Wireshark and tcpdump techniques for troubleshooting and interview preparation.
BBRCUBICTCP
0 likes · 37 min read

This article explains the OSI seven‑layer model, TCP header fields, the three‑way handshake and four‑way termination processes, TIME‑WAIT timing, connection capacity calculations, packet fragmentation and reassembly, flow control, HTTP version differences, HTTPS security flow, and common analysis tools like Wireshark.
HTTP/2OSI modelTCP
0 likes · 15 min read

This article explains TCP fundamentals, detailing the three‑way handshake and four‑step connection termination, the purpose of each flag and state transition, and why three handshakes and four teardowns are required, including the role of the TIME_WAIT state.
TCPTIME_WAITfour-step termination
0 likes · 5 min read

This article explains the SO_LINGER socket option's three closure modes, demonstrates why SO_LINGER=0 sends RST instead of FIN, and outlines Linux's preferred solutions for TIME_WAIT accumulation—connection reuse, tcp_tw_reuse, tcp_fin_timeout, and port range expansion—over abrupt connection termination.
Linux kernelSO_LINGERTCP
0 likes · 16 min read

This article explains TCP as a connection‑oriented, reliable byte‑stream transport protocol, detailing its header fields, state machine, three‑way handshake, four‑way termination, TIME_WAIT handling, Linux inspection commands, optimization techniques, and a comparison with UDP, all illustrated with concrete examples and diagrams.
LinuxSocketTCP
0 likes · 27 min read

TIME_WAIT is a normal TCP state designed to prevent stray packets, but high volumes can indicate inefficient connection handling; this guide explains its mechanics, common causes, monitoring commands, and practical kernel and application-level tuning strategies to reduce TIME_WAIT buildup in high‑traffic services.
LinuxPerformance TuningTCP
0 likes · 12 min read

The article explains the TCP TIME_WAIT state, why it proliferates under high‑concurrency workloads, its impact on ports, memory and performance, and provides practical application‑level optimizations, cautious OS tuning, and monitoring techniques to mitigate the issue.
Connection PoolingLinux tuningTCP
0 likes · 11 min read

TIME_WAIT is a TCP state that appears on the side actively closing a connection; when many sockets linger in this state, ports are exhausted, causing connection failures, and the article explains typical scenarios, underlying causes, kernel limits, and practical client‑ and server‑side solutions.
Connection ManagementLinuxTCP
0 likes · 5 min read

This article explains the TCP state machine, details the four-way handshake, analyzes why the TIME_WAIT state lasts for two MSL intervals, and illustrates two critical problems caused by delayed packets and missing ACKs, providing examples and code snippets for deeper understanding.
Connection ManagementMSLTCP
0 likes · 11 min read

The article walks through every step from typing a URL to final page rendering, detailing URL parsing, DNS lookup, TCP three‑way handshake and termination, HTTP request/response structure, congestion and flow control mechanisms, and the browser’s DOM, CSS, layout and painting processes.
DNSHTTPNetworking
0 likes · 13 min read

This article explains how TCP connections are gracefully closed using the four‑way handshake, describes half‑close and half‑open states, compares the close and shutdown system calls, details the TIME_WAIT state and its impact, and offers practical techniques to reduce or avoid TIME_WAIT accumulation.
Connection terminationShutdownTCP
0 likes · 12 min read

In high‑concurrency scenarios, massive TIME_WAIT TCP connections can exhaust local ports, causing new connections to fail, but by understanding the TCP four‑handshake, adjusting socket reuse settings, and using keep‑alive, you can mitigate the issue.
LinuxNetworkingOperations
0 likes · 8 min read

Under high‑concurrency loads, massive TIME_WAIT TCP connections can exhaust local ports, causing “address already in use” errors; this article explains the root causes, impact on services, and practical mitigation strategies such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT timeout.
TCPTIME_WAIThigh concurrency
0 likes · 7 min read

This article explains why TCP and UDP can share the same port number, how multiple TCP processes handle binding, client port reuse, TIME_WAIT implications, and practical solutions like SO_REUSEADDR and tcp_tw_reuse to avoid address‑in‑use errors.
Linux networkingPort BindingSO_REUSEADDR
0 likes · 17 min read

The article investigates why a MySQL server shows a large number of TCP connections in TIME_WAIT state, examines OS and MySQL logs, tests sysctl adjustments, captures network packets to reveal short‑lived client connections, and concludes that using persistent connections can eliminate the issue.
MySQLTCPTIME_WAIT
0 likes · 6 min read

The article explains why massive TIME_WAIT TCP connections appear during high‑concurrency scenarios, their impact on server ports and new connections, and provides practical analysis and solutions such as keep‑alive headers, socket reuse, and reducing the TIME_WAIT duration.
TCPTIME_WAITnetwork
0 likes · 9 min read

This article explains the purpose of the TCP TIME-WAIT state, the scenarios it protects against, common misconceptions, and practical Linux kernel tweaks—such as fast recycle, socket reuse, and tw_buckets settings—to manage TIME-WAIT efficiently on high‑concurrency servers.
LinuxPerformance TuningTCP
0 likes · 8 min read

This article explains the purpose of the TCP TIME_WAIT state, how it prevents packet loss and connection errors, examines its duration based on the Maximum Segment Lifetime, and analyzes why high‑QPS load testing tools like ab may appear to bypass TIME_WAIT, revealing the impact on server resources.
LinuxSocketTCP
0 likes · 8 min read

The article explains why large numbers of TIME_WAIT TCP connections appear under high concurrency, analyzes the underlying TCP four‑handshake mechanism and port exhaustion issues, and provides practical solutions such as socket reuse, reducing TIME_WAIT duration, and configuring keep‑alive connections.
TIME_WAITnginxserver
0 likes · 10 min read


ITPUBNov 23, 2020 · Fundamentals
This article explains the TCP three‑way handshake and four‑way termination processes, clarifies the TIME_WAIT state, shows how to inspect socket states with netstat, and provides practical Linux sysctl settings to reduce excessive TIME_WAIT sockets and improve network performance.
LinuxNetworkingTCP
0 likes · 7 min read

This article explains the purpose of TCP's three‑way handshake and four‑way termination, walks through the connection lifecycle, highlights the impact of excessive TIME_WAIT sockets, and shows how Linux sysctl parameters can be tuned to improve network performance.
LinuxTCPTIME_WAIT
0 likes · 7 min read

The article explains why massive TIME_WAIT sockets appear during high‑concurrency traffic, how they can exhaust local ports and cause connection errors, and provides practical server‑side and client‑side configurations to mitigate the issue.
NetworkingTCPTIME_WAIT
0 likes · 11 min read

This article explains why massive TIME_WAIT TCP connections appear under high concurrency, the impact on services, and practical methods—such as adjusting socket reuse and reducing TIME_WAIT duration—to prevent new connection failures.
LinuxNetworkingSocket
0 likes · 9 min read

This article explains how an unstable response time caused by misconfigured public load balancers and the kernel parameters net.ipv4.tcp_tw_recycle and net.ipv4.tcp_tw_reuse led to frequent monitoring alerts, details the diagnostic steps taken, and provides concrete remediation recommendations.
TIME_WAITkernel-tuningload balancer
0 likes · 19 min read

The article investigates a Nacos 1.2.0 bug that caused excessive TIME_WAIT connections in Dubbo clients, explains the underlying HttpURLConnection misuse, and reviews TCP three‑way handshake and four‑way termination to illustrate why disconnect() leads to connection buildup.
DubboHttpURLConnectionJava
0 likes · 9 min read

This article examines a MySQL outage triggered by TCP wrappers, detailing how high thread counts, DNS latency, TIME_WAIT socket exhaustion, and frequent reads of /etc/hosts.allow and /etc/hosts.deny can block connections, and provides troubleshooting steps and mitigation recommendations.
DNSMySQLTCP wrappers
0 likes · 11 min read

This article explains why TIME_WAIT occurs, its resource impact, and demonstrates two optimization strategies—accelerating TIME_WAIT reclamation and using the SO_LINGER option to send an RST packet instead of the normal FIN handshake, with complete Go client and server examples and packet‑capture analysis.
RSTSO_LINGERTCP
0 likes · 8 min read

This article walks through a real‑world incident where sudden traffic drops were traced to abnormal TCP states—TIME_WAIT, CLOSE_WAIT, and SYN_RECV—by examining monitoring data, explaining the TCP handshake, reviewing relevant kernel parameters, and debugging Java/ZooKeeper/HBase code to identify and fix the root cause.
HBaseSYN-RECVTCP
0 likes · 20 min read

This article examines why frequent short‑lived TCP connections on Linux trigger the [99] could not assign requested address and [110] connection timeout errors, explains the underlying TIME‑WAIT port exhaustion and listen‑queue overflow mechanisms, and offers verification experiments and practical mitigation strategies.
LinuxTCPTIME_WAIT
0 likes · 8 min read
![Common Short‑Connection Errors [99] and [110] in Linux: Causes, Code Analysis, and Optimizations](https://wsrv.nl/?url=http%3A%2F%2Fmmbiz.qpic.cn%2Fmmbiz_jpg%2FIwabbYzTYkZs8by1XxKcficj9YzpZCr23liaK1lPHZYMiafP3b5sCOflSGEXb0OKddcqwo2ZHCArJQpPrx6icuTibbg%2F0%3Fwx_fmt%3Djpeg)
This article explains the TCP TIME_WAIT state, its role in connection termination, the performance impact of large numbers of TIME_WAIT sockets, and practical optimization methods such as using keep‑alive and tuning Linux kernel parameters to mitigate the issue.
LinuxTCPTIME_WAIT
0 likes · 8 min read


ITPUBSep 13, 2016 · Fundamentals
The article explains why TCP’s TIME_WAIT state is essential for reliable data delivery, describes how excessive TIME_WAIT sockets can exhaust port resources in high‑concurrency short‑connection servers, and offers principled and practical mitigation techniques such as kernel sysctl tweaks and careful use of SO_LINGER.
LinuxNetworkingSocket
0 likes · 9 min read

This article breaks down the TCP three‑way handshake and four‑way termination processes, explaining each packet exchange, the role of sequence numbers, the TIME_WAIT state, and why these steps are essential for reliable full‑duplex communication.
TCPTIME_WAITfour-way termination
0 likes · 8 min read


ITPUBJul 28, 2016 · Operations
This guide shows how to diagnose a flood of MySQL TIME_WAIT sockets, adjust Linux kernel parameters (or Windows registry) to shorten the wait period, verify the improvement, and understand why improper connection handling can cause the issue.
LinuxMySQLTCP
0 likes · 6 min read

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.
HTTPKeep-AliveTCP
0 likes · 6 min read

This article examines three common TCP issues—missing client‑side socket timeouts leading to monitor‑killed processes, excessive TIME_WAIT sockets after service failures and their kernel tunables, and 40 ms keep‑alive latency caused by Nagle and delayed ACK—explaining kernel behavior and offering practical configuration fixes.
Linux kernelNagle algorithmTCP
0 likes · 19 min read

This article explains Linux TIME_WAIT related kernel parameters, their effects on client and server performance, practical tuning recommendations, and how to monitor and resolve high TIME_WAIT counts on busy servers.
LinuxTCPTIME_WAIT
0 likes · 6 min read
