This article explains how HTTP relies on TCP/IP, describes the browser's steps to open a TCP connection, details TCP segment and IP packet structures, outlines socket API calls, and discusses TCP handshake, slow start, and HTTP connection techniques such as parallel, persistent, and pipelined connections.
A 100 M dedicated line with 20 ms latency caused a 22 MB SQL query to take over 25 seconds, prompting an in‑depth analysis of how socket send/receive buffers, sysctl rmem/wmem settings, and TCP windows interact and affect network performance.
The article uses a humorous long‑distance‑call scenario to illustrate why TCP requires a three‑way handshake for reliable connection establishment and a four‑step termination, then details the packet format, flag meanings, handshake steps, and related security considerations.
This article breaks down the five essential questions about how modern browsers handle TCP connections, persistent HTTP requests, pipelining, SSL reuse, and per‑host connection limits when downloading dozens of images on a webpage.
This guide walks through front‑end performance optimization, covering DNS resolution, TCP connection, HTTP request/response, server response techniques like compression and CDN, and browser rendering improvements such as reducing reflows, using lazy loading, and best practices to shrink request time and improve perceived speed.
This article demystifies the OSI networking model by explaining each layer—from the physical hardware connections up to the application protocols—covering concepts such as MAC addresses, IP addressing, subnet masks, TCP/UDP ports, and how data is encapsulated and decapsulated across networks.
This article explains common TCP pitfalls such as sticky packets, how to handle them with proper framing, the importance of heartbeat mechanisms for detecting broken connections, and reliable data validation techniques like length prefixes and MD5 checksums to build robust network applications.
This article provides a comprehensive overview of core Java concepts and related technologies, covering Spring's lifecycle, TCP three-way handshake and four-way termination, thread pool execution flow, JVM memory structure and Java Memory Model, as well as Spring MVC, JDBC, Spring Cloud components, and Dubbo service framework.
This article explains why the author created a custom C++ TCP server framework, outlines the required prerequisites and coding standards, and walks through a minimal echo server implementation together with the key cppbox library interfaces and usage examples.
A detailed investigation shows that an unexpectedly high 39 ms latency in a simple HTTP request is caused by TCP's Nagle algorithm and delayed ACK interactions, and demonstrates how enabling TCP_NODELAY or adjusting ACK timers reduces the delay to under 3 ms.
The article explains how modern browsers handle TCP connections and HTTP requests—including persistent connections, the limits on simultaneous connections per host, the (disabled) HTTP/1.1 pipelining, SSL reuse, and how HTTP/2 multiplexing improves image loading performance.
This article walks through the OSI network model layers—physical, data link, network, transport, and application—explaining hardware components, MAC and IP addressing, subnet masks, TCP/UDP protocols, ports, and how data is encapsulated and decapsulated across each layer.
Using Wireshark, this article dissects a complete HTTP request, explaining the TCP three‑way handshake, window scaling, SACK options, four‑step termination, and Keep‑Alive mechanisms, while illustrating each packet with screenshots and detailing how browsers may merge handshake steps for efficiency.
This article walks through capturing and dissecting an HTTP request with Wireshark, explaining TCP three‑way handshake, window scaling, SACK options, four‑way termination, and Keep‑Alive mechanisms, and shows how browsers may differ in connection handling.
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.
