This article provides a comprehensive technical overview of NVMe architecture, the NVMe‑over‑Fabric extensions—including InfiniBand, RoCE, iWARP, Fibre Channel, and TCP—explaining their RDMA‑based advantages, protocol differences, and practical considerations for data‑center storage deployments.
This article explains TCP fundamentals—including the three‑way handshake, data transmission, and four‑way connection termination—by building a local Python TCP server and client, capturing the traffic with Wireshark, and analyzing each packet in detail.
This article walks through the fundamentals of TCP, explaining its place in the OSI model, the three‑way handshake, window updates, data exchange, and the four‑way termination, while providing complete Python server and client code and Wireshark packet captures to illustrate each step.
This article explains the TCP three‑way handshake and four‑way termination processes, their state transitions, key interview points such as ISN, half‑connection queues, data transmission during handshakes, and the importance of the TIME_WAIT state, providing detailed answers suitable for technical interviews.
The article explains the evolution of NVMe‑oF, compares RDMA, FC and TCP transports, highlights the advantages and challenges of NVMe/TCP in modern data‑center and cloud storage, and discusses Lightbits' LightOS and accelerator card as a cost‑effective solution for high‑performance distributed storage.
This article provides an in‑depth overview of TCP congestion control, covering the sliding‑window flow control, the congestion control state machine with its five states, and the four core algorithms—slow start, congestion avoidance, fast retransmit, and fast recovery—plus practical insights for middleware design.
This article explains key networking concepts including the meaning and differences of HTTP 301/302 status codes, forward versus redirect mechanisms, TCP versus UDP characteristics, the TCP three‑way handshake, OSI layers, GET versus POST request distinctions, and multiple cross‑origin solutions such as JSONP, CORS, window.name, postMessage, and proxies.
This tutorial explains how to install Wireshark, create a virtual network interface for an iPhone, obtain the device UDID, start the virtual interface, and capture TCP/UDP traffic between the iPhone and IoT hardware, including the use of capture and display filters.
This article explains the essential conditions for TCP communication, details the three‑step handshake and four‑step termination processes with packet‑capture illustrations, and discusses why these sequences ensure reliable connections between a client and a server.
The Baidu App reduces connection latency by cutting TLS and TCP round‑trips through session resumption, False Start, pre‑connect, backup and composite connections, and automatic rebuilds, achieving 12‑16 % faster text and image loads and modest success‑rate gains across Android and iOS.
This comprehensive tutorial walks through capturing HTTP traffic with Wireshark and tcpdump, decodes raw TCP packets, explains request and response structures, explores encoding, MIME types, methods, status codes, and advanced topics such as proxies, caching, cookies, redirection, and connection management, giving developers a solid understanding of how HTTP works under the hood.
This article explains the principles behind TCP's three‑way handshake and four‑way teardown, covering connection establishment, data transfer, termination, header fields, state diagrams, sequence‑number wraparound, SYN‑flood attacks, mitigation techniques, and a practical Redis packet‑capture analysis, all illustrated with diagrams and code snippets.
The article analyzes why Sysbench‑driven MySQL connections time out when concurrency exceeds 5 000, tracing the issue to TCP SYN‑cookie processing and a full accept queue, and proposes configuration‑level mitigations.
The article investigates intermittent TCP connection failures during application server startup caused by the Linux kernel ARP queue length parameter unres_qlen, reproduces the issue with a concurrent connection test, analyzes kernel internals, and recommends increasing unres_qlen for kernels prior to 3.3.
Upcoming IETF discussions aim to replace the long‑standing TCP‑based HTTP with a new UDP‑based protocol, QUIC, rebranded as HTTP/3, offering lower latency and improved security, while distinguishing Google’s gQUIC from the IETF’s iQUIC and gaining industry support.
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.
This article introduces fundamental network programming concepts, including OSI and TCP/IP layering, TCP connection establishment and termination, essential socket functions for client and server, key terms like backlog and RTT, the stream nature of TCP, and various I/O models such as blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous I/O.
Understanding TCP state transitions, common diagnostic commands, and the detailed processes of connection establishment, termination, and related issues such as SYN flood, TIME_WAIT, and keepalive mechanisms equips engineers to troubleshoot network and system faults effectively.
This comprehensive guide walks you through the core concepts of computer networking, including the OSI and TCP/IP models, detailed explanations of TCP and UDP protocols, HTTP fundamentals, socket programming, IP addressing, ICMP, ping operations, and the differences between routers, switches, cookies, sessions, and tokens.
This article explains the TCP header layout, details each field and control flag, and walks through the three‑way handshake for connection establishment and the four‑step termination process, including why these specific numbers of steps are required and the purpose of the 2 MSL wait.
This article uses animated analogies to demystify TCP’s three‑way handshake, data transmission nuances, and four‑way connection termination, explaining states like SYN_SENT, SYN_RCVD, ESTABLISHED, and TIME_WAIT, while also covering retransmission, flow control, and packet ordering in an easy‑to‑understand visual format.
This article introduces the fundamentals of Linux and open‑source software, covering GNU and GPL licensing, typical Linux distributions, Unix roots, swap partitions, GRUB bootloader, buffer vs cache, TCP three‑way handshake, filesystem hierarchy, hard/soft links, and an overview of RAID levels.
This article explains the fundamental differences between GET and POST requests, the dual TCP/UDP usage of DNS, the meaning of idempotence, the contrast between cookies and sessions, causes and solutions for TCP packet fragmentation, the three‑way handshake and four‑way termination, the complete HTTP request flow, long‑connection handling, TCP reliability mechanisms, detailed HTTP structure, the distinction between URI and URL, and how HTTPS secures data transmission.
This article explains how TCP three‑way handshake, half‑ and full‑connection queues, and the backlog setting can cause intermittent client‑server connection failures, and shows how to detect and resolve queue overflows using netstat, ss, and proper backlog configuration.
This article demystifies socket communication by illustrating the end‑to‑end process of TCP/UDP message exchange, detailing how client and server serialize objects, interact with kernel read/write buffers, handle blocking, acknowledgments, packet headers, and flow control, and why understanding these low‑level mechanisms is crucial for reliable network programming.
This article uses simple animations and analogies to demystify TCP’s three‑way handshake, data transmission nuances, and the four‑way connection termination, explaining key states like SYN_SENT, SYN_RCVD, and TIME_WAIT while also covering retransmission, duplicate‑ack handling, and window sizing.
This article explains the concept of HTTP pipelining, presents a series of performance tests comparing pipe, thread‑group, and asynchronous request methods on a typical PC, analyzes the results and underlying TCP behavior, and provides a simple .NET implementation for practical use.
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.
When clients frequently use short TCP connections they often encounter error 110 (connection timeout) and error 99 (cannot assign requested address), which stem from TIME‑WAIT port exhaustion and server listen‑queue overflow, and this article explains the causes and practical solutions.
The article walks through a real‑world case where an e‑commerce homepage intermittently became unreachable, explains how SYN socket overflow and full accept queues cause TCP handshake failures, demonstrates kernel and Nginx tuning, and provides Python scripts for load testing and SYN‑Flood simulation.
This article walks through a real‑world incident where an e‑commerce site suffered intermittent outages due to TCP SYN and accept queue overflows, explains the underlying handshake mechanics, shows how kernel and Nginx parameters can be tuned, and provides Python scripts for testing and SYN‑flood simulation.
This article explains the basic principles of the TCP protocol, covering its purpose in ensuring reliable data transmission, packet size limits, sequence numbering, how packets are reassembled by the operating system, the slow‑start mechanism with ACK handling, and methods for detecting and retransmitting lost packets.
This tutorial explains the fundamentals of Proof‑of‑Stake, compares it with Proof‑of‑Work, and provides a step‑by‑step Go implementation of a PoS blockchain with TCP networking, validator selection, and code snippets for building and running the system.
This article explains the TCP connection process, detailing socket creation, the roles of send and receive buffers, the functions socket(), bind(), listen(), accept(), and how address/port reuse and SYN flood mitigation affect performance and reliability.
This article explains why TCP requires a three‑way handshake to establish connections and a four‑step termination process, using a relatable video‑call scenario and detailed protocol diagrams to illustrate the underlying mechanisms and practical rules for confirming audio transmission.
The article uses a quirky long‑distance video‑chat scenario to illustrate TCP’s three‑way handshake and four‑way termination, explaining the protocol’s packet format, flag meanings, SYN‑attack risks, and step‑by‑step connection establishment and teardown.
This article investigates an intermittent timeout issue caused by a Java Apache HttpClient implementation that leaks connections, explains why numerous RST packets appear during TLS shutdown, and presents experiments and code revisions that clarify the TCP/TLS interaction and proper resource handling.
This article explains what head‑of‑line blocking is in HTTP, why HTTP/1.1 suffers from it, how HTTP/2 over TCP mitigates request‑level blocking but not transport‑level issues, and how QUIC over UDP fully resolves the problem.
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.
This article compiles 35 Linux operations interview questions—including multiple‑choice, coding, and essay topics—along with detailed answers covering VLANs, system calls, IP addressing, TCP/UDP, process handling, data structures, and networking fundamentals to help candidates prepare effectively.
A comprehensive guide to common Linux operations interview questions, covering environment variables, TCP characteristics and handshake, proxy principles, TCP vs UDP trade‑offs, OOP vs procedural programming, HTTP request flow and status codes, deadlock concepts, TCP states, and inter‑process communication mechanisms.
This article provides a comprehensive guide to Java network programming, covering TCP/IP basics, socket concepts, InetAddress and URL APIs, detailed TCP and UDP client‑server implementations, multithreaded server handling, and practical code examples for building robust network applications.
This article compiles essential Linux environment variable settings, TCP characteristics, three‑handshake rationale, proxy implementation, TCP vs UDP pros and cons, OOP vs procedural differences, HTTP request flow, status codes, deadlock causes and prevention, TCP close_wait and time_wait states, and common IPC mechanisms, providing concise answers for operations interview preparation.
The article explains TCP as a connection‑oriented protocol, contrasts it with UDP, details the three‑way handshake and four‑way termination processes using clear steps and analogies, and includes illustrative diagrams to aid comprehension.
Learn how TCP’s three-way handshake and four-way termination work in detail, illustrated with Wireshark packet captures, and understand why each step is necessary through clear explanations and real‑world analogies that demystify network connection establishment and closure.
This article details the architecture and key technologies of JD’s open platform, including a high‑performance API gateway, unified metadata configuration, TCP full‑duplex long‑connection channels, Protobuf data exchange, multi‑dimensional flow control, and a reliable message‑push system designed for massive 618‑scale traffic.
This article explains how JD’s 京麦 open platform evolved from a simple Nginx‑Tomcat deployment to a decentralized, high‑performance API gateway and robust TCP‑based messaging system, detailing architectural choices such as OAuth2, ZooKeeper‑driven metadata, multi‑level rate limiting, Protobuf, and Netty‑powered push services.
This article explains how Node.js handles HTTP requests using an I/O multiplexing model, walks through a simple hello‑world server, examines connection and request events, discusses keep‑alive, Expect headers, proxying, and presents performance measurements comparing Node.js to a pure C implementation.
The common belief that a machine can only handle 65,536 TCP connections is a misconception; in theory and practice a server or client can manage far more connections, depending on IP, port, and system limits.
This article explains the role of TCP within the Internet protocol stack, details packet size limits, sequence numbering, assembly, slow‑start and ACK mechanisms, and how TCP ensures reliable, ordered data transmission despite packet loss.
This guide explains why the default Linux kernel settings are unsuitable for high‑concurrency Nginx servers, shows how to edit /etc/sysctl.conf, and provides a curated list of TCP and network parameters with practical comments to improve throughput and latency.
A poetic tale follows a programmer’s evolution from using shared memory for secret messages to mastering sockets, TCP handshakes, firewalls, and HTTP‑based web services, illustrating core networking concepts through a heartfelt metaphor.
This article provides a comprehensive overview of the 65,535 possible TCP/UDP ports, highlighting frequently used ports, their associated services, typical vulnerabilities, and how attackers may exploit them, helping readers quickly reference and secure network configurations.
This article explains the fundamentals of Java socket programming, covering what sockets are, the three essential components for establishing a connection, sample server and client code, connection monitoring techniques, multithreaded handling of multiple clients, and UDP communication with practical considerations.
This guide introduces Wireshark’s packet capture process, from selecting network interfaces and configuring capture filters to analyzing captured data with display filters, interpreting protocol layers, and performing detailed TCP flow analysis, providing practical examples and filter expressions for effective network troubleshooting and security investigations.
This article explains how load balancers act as the nervous system of web applications, compares hardware versus open‑source solutions, and details why HAProxy—especially in TCP (layer 4) mode—often outperforms Nginx for high‑performance reverse proxy and load‑balancing tasks.
This article examines the critical factors influencing web performance—including network latency, TCP/HTTP protocols, browser rendering, and server-side architecture—and provides practical optimization techniques such as TCP tuning, HTTP/2 adoption, resource compression, caching, load balancing, and distributed design to achieve fast, scalable web services.
This article examines WeChat's Mars STN module, detailing TCP connection timeout handling, the trade‑offs between serial, concurrent and composite connection strategies, and the evolution of IP‑Port sorting algorithms—from random combinations to history‑aware and forgetting mechanisms—to achieve high performance, low load, and high availability on mobile networks.
The article explains the TCP handshake spoofing technique, showing how the 32‑bit sequence and acknowledgment fields can be abused to impersonate a client, the traffic volume required for a successful attack, and why TLS is the recommended mitigation.
This article explains RPC fundamentals, its advantages, serialization processes, and provides a step‑by‑step TCP‑based Java RPC implementation with code examples and performance comparisons, helping backend developers understand and build simple remote procedure call systems.
This article explores the design and experimentation of read/write timeout mechanisms in WeChat's STN module, detailing TCP/IP timeout behavior, mobile platform variations, and three layered application‑level strategies—total, stepwise, and dynamic—to improve reliability and user experience on unstable networks.
This article explains the TCP three‑way handshake, how SYN Flood attacks exhaust server resources, and outlines Linux mitigation methods such as adjusting sysctl parameters, SYN Cache, and SYN Cookies, while discussing their trade‑offs and attacker strategies.
This article explains what DDoS attacks are, outlines their main categories—including high‑volume floods, TCP state‑exhaustion attacks, and application‑layer assaults—describes how each operates, and highlights why modern DDoS threats have shifted toward sophisticated application‑level techniques.
This article explains the complete journey of a web request—from DNS lookup and TCP handshake through HTTP exchange, server processing, and browser rendering—while highlighting optimization techniques and the roles of front‑end and back‑end engineers.
This article explains the TCP three‑way handshake, four‑way termination, and related state transitions, illustrates uncommon scenarios such as simultaneous open and close, discusses half‑open connections, fd‑leak effects, and presents Linux‑based experiments with client.go and server.go code samples.
This article provides a comprehensive introduction to TCP, covering its header structure, optional fields, the role of MSS and TSO, mechanisms for reliability and retransmission, as well as detailed explanations of flow control, sliding windows, and congestion control algorithms.
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.
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.
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.
This guide explains how to set up NAT server and NAT outbound on a Huawei router so that internal users can access a server via the router's WAN IP on port 80 and external users can reach the same server using port 8089, including required ACL and interface configurations.
This comprehensive guide walks through HAProxy's version landscape, connection and closing modes, load‑balancing algorithms, persistence, content routing, header rewriting, multiple configuration examples—including dynamic and multi‑process setups—and practical debugging tips, supplemented by a live Q&A session.
This article provides a comprehensive overview of HTTP, TCP, UDP, and socket communication, explaining protocol layers, request/response structures, key headers, and the differences between GET and POST methods for web development.
This guide explains how to raise Linux user‑process file descriptor limits, adjust kernel TCP parameters, and use efficient I/O mechanisms such as epoll or AIO to support thousands of simultaneous TCP connections for high‑concurrency network programs.
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 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.
This article explains the structure and fields of IP packets, including version, header length, TOS, total length, ID, flags, fragment offset, TTL, protocol, checksum, source and destination addresses, as well as the formats and key functions of TCP and UDP headers, highlighting their differences.
This guide introduces Python’s socket module, explains socket families and types, details essential server and client functions, walks through step‑by‑step TCP connection creation, and provides complete server and client code examples for practical network programming.
This article outlines Baidu Maps' mobile network optimization strategies, covering the overall architecture, common wireless issues such as DNS failures and hijacking, and practical solutions like HTTP‑DNS, custom TCP/UDP HTTP, data compression, unified domain entry, and deployment tactics that significantly improve user search latency and engagement.
This article explores four high‑performance TCP server models in .NET/C#—Asynchronous Programming Model (APM), Task‑based Asynchronous Pattern (TAP), SocketAsyncEventArgs (SAEA), and Registered I/O (RIO)—detailing their accept and read loops, implementation nuances, pooling strategies, and sample code, while highlighting performance considerations and real‑world usage.
This article details the design and implementation of 58’s real‑time messaging platform, covering its business background, overall architecture, protocol design for extensibility and debugging, and solutions for fast TCP reconnection to ensure stable, high‑throughput delivery for intra‑city freight services.
With broadband speeds soaring, UDP’s simplicity and low latency now outperform TCP in web browsing, streaming, gaming, and IoT, as real‑world tests from Akamai and Google show dramatically lower packet loss, faster connections, and reduced buffering, signaling a shift toward UDP‑centric networking.
Ctrip's wireless development team shares a comprehensive overview of their app's network architecture, common performance pitfalls such as DNS and TCP issues, and a series of practical optimizations—including DNS caching, quality detection, priority handling, retransmission, payload reduction, and protocol upgrades—that dramatically improved service success rates and reduced latency.
Ctrip's wireless development director shares a comprehensive overview of the app's network architecture, common performance pitfalls, and six concrete optimization techniques that boosted service success rates above 99% and cut latency by up to 200 ms across diverse network conditions.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, and compares long‑lasting persistent connections with short‑lived ones, covering their handshakes, advantages, disadvantages, and appropriate usage scenarios.
This article explains how HTTP relies on TCP/IP, clarifies the stateless nature of HTTP, compares short and long connections in HTTP/1.0 and HTTP/1.1, and discusses the advantages, disadvantages, and appropriate use cases for each connection type.
This article explains how to add Protocol Buffer communication to a PHP web system, covering library setup, proto file adjustments, code generation, binary TCP handling with pack/unpack, and the switch from read_line to fread for reliable socket reads.
This article discusses whether PC1 can successfully access PC2’s web service when outbound traffic passes through a NAT router but the return packets bypass the router via a core switch, examining potential TCP connection issues caused by asymmetric routing and providing relevant ACL and NAT configuration examples.
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 details the analysis and redesign of Line, WhatsApp, and WeChat heartbeat mechanisms, presenting a simplified adaptive heartbeat algorithm, its testing methodology, comparative push strategies, GCM characteristics, and practical improvement suggestions to reduce power consumption, network load, and latency.
This guide explains how to increase Linux's per-process file descriptor limits, adjust kernel TCP parameters, and adopt high-performance I/O models such as epoll or AIO to support tens of thousands of concurrent TCP connections.
HAProxy is an open‑source, high‑performance load‑balancing software that operates at both layer 4 (TCP) and layer 7 (HTTP), offering strong reliability, massive concurrency handling, flexible algorithms, and powerful monitoring, making it ideal for large‑scale web and database workloads.
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.
The article details Ctrip's mobile app network service architecture, explaining native TCP and hybrid HTTP communication, describing common performance issues such as DNS, TCP, payload size, and presents six optimization practices—including DNS caching, quality detection, priority handling, retransmission, payload reduction, and overseas network improvements—to achieve higher success rates and lower latency.
This article explains the Linux TCP connection‑establishment, packet‑receive, and packet‑send paths, categorizes related kernel parameters such as backlog, SYN‑cookie, ring buffers, and socket buffers, and provides practical commands and guidelines for optimizing network performance on servers.
The article details Ctrip's mobile app network architecture, common performance bottlenecks such as DNS, TCP, and payload issues, and presents six practical optimization techniques—including DNS caching, network‑quality detection, service prioritization, retry mechanisms, payload compression, and overseas CDN improvements—that collectively reduced latency by 150‑200 ms and raised service success rates above 99 %.
This article analyzes common push‑service questions, presents a real‑world IoT case of memory leakage, and outlines key design points—including kernel limits, CLOSE_WAIT handling, heartbeat configuration, buffer management, memory pooling, logging pitfalls, TCP tuning, and JVM settings—to build a scalable, stable Netty‑based push server for millions of concurrent connections.
This article explains the TCP three-way handshake and four-way termination processes, detailing each packet exchange, state transition, and the reasons why these mechanisms are essential for reliable network communication.
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.
This article demystifies TCP optimization by explaining flow control, slow start, congestion avoidance, and practical methods to tune the receive and congestion windows (rwnd and cwnd) on Linux systems for better network performance.
This article explains TCP fundamentals—including three‑way handshakes, sliding windows, and four‑way termination—then details how the RST flag works and how attackers can forge packets using source ports and sequence numbers to execute powerful RST denial‑of‑service attacks.
