BestHub
Sign in
Tagged articles

TCP

614 articles · Page 3 of 7
Wukong Talks Architecture
Wukong Talks Architecture
Aug 31, 2023 · Fundamentals

Understanding DNS: Principles, Resolution Process, and Performance Optimization

This article explains the fundamentals of the Domain Name System (DNS), covering domain and name‑server concepts, the hierarchical resolution process, recursive and iterative queries, performance‑enhancing techniques such as UDP usage, caching, and switching to public DNS servers, and details DNS record types and packet structure.

DNSDomain Name SystemTCP
0 likes · 14 min read
Understanding DNS: Principles, Resolution Process, and Performance Optimization
Su San Talks Tech
Su San Talks Tech
Aug 21, 2023 · Backend Development

Why Use RPC When HTTP Exists? Understanding TCP, HTTP, and RPC Differences

This article explains the fundamentals of TCP, why pure TCP communication faces boundary issues, how HTTP and RPC are built on TCP as application‑layer protocols, and compares their architectures, service discovery, serialization, and performance to clarify when each should be used.

Backend DevelopmentHTTPRPC
0 likes · 15 min read
Why Use RPC When HTTP Exists? Understanding TCP, HTTP, and RPC Differences
Open Source Linux
Open Source Linux
Aug 14, 2023 · Fundamentals

Why Choose TCP Long Connections Over Short Ones? A Deep Dive

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.

HTTPKeep-AliveTCP
0 likes · 12 min read
Why Choose TCP Long Connections Over Short Ones? A Deep Dive
Senior Tony
Senior Tony
Aug 9, 2023 · Backend Development

Why Netty Powers Modern Java Back‑ends: A Deep Dive into Its Architecture

This article explains what Netty is, why it’s essential for Java back‑end development, details its core components and high‑performance mechanisms such as the Reactor model, Zero‑Copy and object pooling, and shows how Netty handles TCP framing issues with practical decoding solutions.

NettyNetwork ProgrammingObject Pool
0 likes · 9 min read
Why Netty Powers Modern Java Back‑ends: A Deep Dive into Its Architecture
MaGe Linux Operations
MaGe Linux Operations
Aug 7, 2023 · Fundamentals

Short vs Long TCP Connections: When to Use Each and How to Keep Them Alive

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.

HandshakeTCPkeepalive
0 likes · 10 min read
Short vs Long TCP Connections: When to Use Each and How to Keep Them Alive
Liangxu Linux
Liangxu Linux
Aug 6, 2023 · Operations

Why Does Your Network Lose Packets? 30+ Troubleshooting Steps Revealed

This article explains the concept of network packet loss, walks through the sending and receiving mechanisms of Ethernet frames, and provides a comprehensive, layer‑by‑layer checklist—including hardware NIC, driver, kernel, IP, TCP/UDP, and application‑level diagnostics—plus concrete Linux commands and configuration tweaks to locate and fix the root cause.

Packet lossTCPdiagnostics
0 likes · 36 min read
Why Does Your Network Lose Packets? 30+ Troubleshooting Steps Revealed
Tencent Database Technology
Tencent Database Technology
Jul 27, 2023 · Databases

MySQL Network Write Timeout (Error 1161) Analysis and Debugging

This article investigates a MySQL 8.0 TDSQL client experiencing connection interruptions during batch streaming, analyzes error 1161 (ER_NET_WRITE_INTERRUPTED) root causes in the MySQL source code, presents debugging steps with log and packet captures, and offers practical mitigation recommendations.

Database PerformanceError 1161MySQL
0 likes · 11 min read
MySQL Network Write Timeout (Error 1161) Analysis and Debugging
Open Source Linux
Open Source Linux
Jul 24, 2023 · Fundamentals

Why TCP Beats UDP: Ports, Handshakes, and Flow Control Explained

This article explains the transport layer’s core protocols—TCP and UDP—detailing their functions, differences, port numbers, connection establishment, reliability mechanisms, flow and congestion control, and how applications use client‑server models to communicate over networks.

Port NumbersReliabilityTCP
0 likes · 21 min read
Why TCP Beats UDP: Ports, Handshakes, and Flow Control Explained
MaGe Linux Operations
MaGe Linux Operations
Jul 18, 2023 · Fundamentals

Short vs Long TCP Connections: When and Why to Use Each

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.

Keep-AliveTCPlong-connection
0 likes · 12 min read
Short vs Long TCP Connections: When and Why to Use Each
Architecture Digest
Architecture Digest
Jul 6, 2023 · Backend Development

Implementing Microservices in Node.js with NestJS: Concepts, Benefits, and Step‑by‑Step Guide

This article explains what microservices are, when they should be used, their pros and cons, communication patterns, why Node.js is a good fit, and provides a detailed NestJS‑based implementation with code examples for building, testing, and exposing a user‑management microservice through an API gateway.

API GatewayNestJSNode.js
0 likes · 13 min read
Implementing Microservices in Node.js with NestJS: Concepts, Benefits, and Step‑by‑Step Guide
MaGe Linux Operations
MaGe Linux Operations
Jul 4, 2023 · Fundamentals

Mastering TCP & UDP: Headers, Flow Control, Handshakes, and Congestion Explained

This article provides a comprehensive overview of TCP and UDP protocols, covering TCP header fields, flow and congestion control mechanisms, three-way handshake and four-way termination, reliability guarantees, as well as a detailed comparison with UDP, including connection orientation, broadcast support, and header overhead.

Congestion ControlFlow ControlTCP
0 likes · 10 min read
Mastering TCP & UDP: Headers, Flow Control, Handshakes, and Congestion Explained
MaGe Linux Operations
MaGe Linux Operations
Jul 1, 2023 · Fundamentals

Ensuring 60‑Second TCP Keep‑Alive During Unstable Networks

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.

RetransmissionTCPWindows
0 likes · 22 min read
Ensuring 60‑Second TCP Keep‑Alive During Unstable Networks
21CTO
21CTO
Jun 6, 2023 · Backend Development

Mastering TCP/UDP, Sockets, and Connection Pools: From OSI Model to Node.js

This comprehensive guide walks you through the OSI seven‑layer model, explains TCP and UDP fundamentals, details the three‑way handshake and four‑way termination, compares long and short connections, introduces heartbeat packets, and demonstrates how to build a custom protocol and a socket connection pool in Node.js.

Connection PoolNetwork ProtocolsNode.js
0 likes · 16 min read
Mastering TCP/UDP, Sockets, and Connection Pools: From OSI Model to Node.js
Open Source Linux
Open Source Linux
Jun 5, 2023 · Operations

Mastering iperf: Install, Configure, and Run TCP/UDP Bandwidth Tests

This guide explains how to install iperf on Windows and Linux, configure it for TCP and UDP bandwidth testing, adjust UDP buffer settings, and interpret the resulting performance metrics, providing practical command examples and visual output for accurate network performance analysis.

LinuxPerformanceTCP
0 likes · 8 min read
Mastering iperf: Install, Configure, and Run TCP/UDP Bandwidth Tests
Architecture Digest
Architecture Digest
May 29, 2023 · Fundamentals

Understanding Network Protocols, TCP/UDP Handshakes, Socket Long Connections, and Socket Connection Pools

This article explains the OSI seven‑layer model, the principles and handshake processes of TCP and UDP, the differences between them, the concept of long‑living socket connections with heartbeats, custom application‑layer protocols, and how to implement a reusable socket connection pool in Node.js.

Connection PoolNetwork ProtocolsNode.js
0 likes · 16 min read
Understanding Network Protocols, TCP/UDP Handshakes, Socket Long Connections, and Socket Connection Pools
MaGe Linux Operations
MaGe Linux Operations
May 28, 2023 · Fundamentals

Master TCP/UDP, Sockets & Connection Pools: From OSI Model to Node.js

This article walks developers through network protocol fundamentals, explaining the OSI seven‑layer model, TCP three‑handshake and four‑teardown processes, UDP characteristics, long‑vs‑short connections, heartbeat mechanisms, custom protocol design, and a practical Node.js socket connection‑pool implementation.

Connection PoolNetwork ProtocolsNode.js
0 likes · 16 min read
Master TCP/UDP, Sockets & Connection Pools: From OSI Model to Node.js
Architect
Architect
May 25, 2023 · Fundamentals

Understanding Network Protocols, TCP/UDP Handshakes, and Socket Connection Pools

This article explains the OSI seven‑layer model, the differences between TCP and UDP, the three‑way handshake and four‑step termination processes, long‑living socket connections, heartbeat mechanisms, custom application‑layer protocols, and how to implement a socket connection pool using Node.js.

Backend DevelopmentConnection PoolNetwork Protocols
0 likes · 17 min read
Understanding Network Protocols, TCP/UDP Handshakes, and Socket Connection Pools
DeWu Technology
DeWu Technology
May 19, 2023 · Operations

Investigation and Resolution of In‑flight Wi‑Fi Connectivity Issues for a Mobile E‑Commerce App

The SRE team diagnosed an in‑flight Wi‑Fi outage for the DeWu e‑commerce app by reproducing the problem, capturing packets with ping, traceroute and tcpdump, discovered a firewall rule misclassifying the domain as a download site, and resolved it through a vendor‑issued policy update, restoring connectivity on both ATG and SATCOM links.

SRETCPWiFi
0 likes · 18 min read
Investigation and Resolution of In‑flight Wi‑Fi Connectivity Issues for a Mobile E‑Commerce App
Top Architect
Top Architect
May 6, 2023 · Backend Development

Netty TCP Client Demo with Spring Boot: Architecture, Message Queue, and Complete Code Walkthrough

An in‑depth tutorial demonstrates building a Netty‑based TCP client with Spring Boot, covering project architecture, module layout, message‑queue simulation, detailed Java code for client creation, connection handling, and testing endpoints, providing a complete, production‑ready demo for IoT socket communication.

Message QueueNettySocket
0 likes · 26 min read
Netty TCP Client Demo with Spring Boot: Architecture, Message Queue, and Complete Code Walkthrough
Top Architect
Top Architect
Apr 21, 2023 · Backend Development

Netty TCP Long‑Connection Demo for IoT Messaging with Redis and Spring Boot

This article presents a complete Netty‑based TCP client/server demo for IoT long‑connection messaging, explains the project architecture, module layout, business flow, and provides detailed Java code for a local message queue, multithreaded processing, client creation, handler logic, and testing endpoints.

IoTMessageQueueNetty
0 likes · 19 min read
Netty TCP Long‑Connection Demo for IoT Messaging with Redis and Spring Boot
Open Source Linux
Open Source Linux
Apr 20, 2023 · Operations

Diagnosing Linux Network Latency with hping3, traceroute, and Wireshark

This article explains how to identify the root causes of increased network latency on Linux servers by using tools such as hping3, traceroute, wrk, tcpdump, and Wireshark, demonstrating step‑by‑step measurements, analysis of TCP delayed acknowledgments, and practical recommendations for mitigating latency in production environments.

LinuxPerformanceTCP
0 likes · 17 min read
Diagnosing Linux Network Latency with hping3, traceroute, and Wireshark
Open Source Linux
Open Source Linux
Apr 20, 2023 · Fundamentals

Why TCP Window Full Slows Your Transfers and How to Diagnose It

This article explains how TCP Window Full warnings indicate a full receiver window, how to interpret Wireshark's Expert Information, locate the relevant packets, calculate bytes in flight, and use graphs to diagnose and verify the impact on transfer speed.

Bytes in FlightNetwork PerformanceTCP
0 likes · 18 min read
Why TCP Window Full Slows Your Transfers and How to Diagnose It
AI Cyberspace
AI Cyberspace
Apr 18, 2023 · Fundamentals

Why HTTP/2 Beats HTTP/1.1: Deep Dive into Requests, Responses, and Pipelining

This article explains the structure of HTTP/1.1 request and response messages, the limitations of TCP such as head‑of‑line blocking, the evolution from SPDY to HTTP/2 with binary framing, multiplexed streams, header compression, server push, ALPN negotiation, and practical Wireshark capture techniques for HTTP/2 traffic.

HTTPHTTP/2TCP
0 likes · 24 min read
Why HTTP/2 Beats HTTP/1.1: Deep Dive into Requests, Responses, and Pipelining
Liangxu Linux
Liangxu Linux
Apr 13, 2023 · Fundamentals

Why TCP Window Full Slows Your Transfer and How to Diagnose It with Wireshark

This article walks through a real‑world case of slow file copying between Beijing and Shanghai data centers, explains why Wireshark reports “TCP Window Full”, shows how to locate the relevant packets, calculate bytes‑in‑flight, and assess the impact on transfer speed using I/O graphs and window‑scaling analysis.

Bytes in FlightNetwork PerformanceTCP
0 likes · 18 min read
Why TCP Window Full Slows Your Transfer and How to Diagnose It with Wireshark
AI Cyberspace
AI Cyberspace
Apr 10, 2023 · Fundamentals

Mastering TCP: Header Structure, Handshake, Flow & Congestion Control Explained

This comprehensive guide delves into TCP’s core mechanisms—including header fields, segmentation and reassembly, the three‑way handshake and four‑step termination, sliding‑window flow and congestion control, retransmission strategies, and connection design patterns—providing a solid foundation for network engineers and developers.

Congestion ControlFlow ControlSliding Window
0 likes · 26 min read
Mastering TCP: Header Structure, Handshake, Flow & Congestion Control Explained
Liangxu Linux
Liangxu Linux
Apr 9, 2023 · Operations

Master Wireshark: Advanced Packet Filtering, Timing, and Analysis Techniques

This guide walks through Wireshark's powerful features—including precise packet filtering, time‑display adjustments, absolute sequence numbering, exporting filtered captures, traffic statistics, decoding mixed logs, TCP stream tracing, and MAC‑address vendor lookup—to help engineers troubleshoot and analyze network traffic efficiently.

FilteringTCPTroubleshooting
0 likes · 6 min read
Master Wireshark: Advanced Packet Filtering, Timing, and Analysis Techniques
Liangxu Linux
Liangxu Linux
Apr 2, 2023 · Fundamentals

How NAT and NAPT Translate Private IPs and Enable Intranet Penetration

This article explains why home networks use private 192.168.x.x addresses, how NAT devices translate private IPs to a single public IP, the detailed SNAT/DNAT processes, the role of ports in NAPT, and how these mechanisms enable inbound connections through techniques like NAT hole punching and intranet penetration.

IP translationNAPTNAT
0 likes · 15 min read
How NAT and NAPT Translate Private IPs and Enable Intranet Penetration
Open Source Linux
Open Source Linux
Mar 27, 2023 · Fundamentals

How Many TCP Connections Can a Single Server Actually Handle?

While TCP’s 16‑bit port range suggests a theoretical limit of 65,535 connections, real‑world server concurrency depends on factors like memory, file descriptor limits, port reuse, and operating‑system constraints, allowing modern Linux servers to support hundreds of thousands or even millions of simultaneous connections.

LinuxTCPconcurrent connections
0 likes · 11 min read
How Many TCP Connections Can a Single Server Actually Handle?
MaGe Linux Operations
MaGe Linux Operations
Mar 26, 2023 · Fundamentals

Master the TCP/IP Stack: 10 Essential Concepts Every Engineer Must Know

This comprehensive guide walks you through the TCP/IP protocol suite, covering the four-layer model, data link, network, transport, and application layers, and explains key protocols such as IP, ARP, ICMP, TCP, UDP, DNS, as well as connection management, flow control, and congestion control techniques.

Congestion ControlFundamentalsTCP
0 likes · 17 min read
Master the TCP/IP Stack: 10 Essential Concepts Every Engineer Must Know
Selected Java Interview Questions
Selected Java Interview Questions
Mar 22, 2023 · Backend Development

Netty TCP Demo: Architecture, Code Walkthrough, and Usage Guide

This article presents a comprehensive Netty TCP demo project, covering its architecture, module layout, business flow, detailed Java code for message queuing, client execution, handler implementation, testing endpoints, and deployment considerations, providing a practical learning resource for backend developers.

NettyRedisSocket
0 likes · 21 min read
Netty TCP Demo: Architecture, Code Walkthrough, and Usage Guide
IT Services Circle
IT Services Circle
Mar 20, 2023 · Fundamentals

Comprehensive Interview Review: Networking, TCP/IP, Epoll, Redis, MySQL MVCC, and C++ Concepts

This article compiles a detailed interview guide covering TCP/UDP differences, three‑way handshake and four‑way termination, flow and congestion control, select/poll/epoll mechanisms, zero‑copy techniques, Redis advantages and persistence, MySQL MVCC and repeatable‑read semantics, as well as core C++ topics and common algorithm questions.

C#DatabaseMySQL
0 likes · 19 min read
Comprehensive Interview Review: Networking, TCP/IP, Epoll, Redis, MySQL MVCC, and C++ Concepts
Architect
Architect
Mar 14, 2023 · Fundamentals

Why HTTP/3 Replaces TCP: Understanding QUIC and Protocol Evolution

The article explains how HTTP/3 abandons TCP in favor of the QUIC protocol built on UDP, detailing TCP's head‑of‑line blocking, handshake latency, middlebox rigidity, and how QUIC’s reliability, multiplexing, and fast handshakes address these issues while also noting deployment challenges.

HTTP/3QUICTCP
0 likes · 7 min read
Why HTTP/3 Replaces TCP: Understanding QUIC and Protocol Evolution
Liangxu Linux
Liangxu Linux
Mar 7, 2023 · Fundamentals

Why 65,535 Isn’t the Real Limit for TCP Connections on Linux

The article explains that the 65,535 TCP port limit does not bound a Linux server’s concurrent connections, detailing how TCP connections are identified, the theoretical maximum of 2⁴⁸ connections for a server, and the practical constraints imposed by memory and file‑descriptor limits.

LinuxSocketTCP
0 likes · 11 min read
Why 65,535 Isn’t the Real Limit for TCP Connections on Linux
Architect
Architect
Mar 2, 2023 · Fundamentals

Understanding the Maximum Concurrent TCP Connections and the Origin of the 65535 Limit

The article explains how TCP connections are identified by a four‑tuple, why the theoretical maximum client connections are 65,535 due to port limits, how servers can theoretically handle up to 2⁴⁸ connections, and why real‑world concurrency is constrained by memory, file descriptors and port reuse rather than the 65535 port count.

LinuxPort NumbersTCP
0 likes · 12 min read
Understanding the Maximum Concurrent TCP Connections and the Origin of the 65535 Limit
ELab Team
ELab Team
Mar 2, 2023 · Backend Development

Node.js TCP Connections Explained: Event Loop & Libuv Architecture

This article walks through a complete TCP connection example in Node.js, detailing server and client code, the three-layer Node.js architecture (JS, C++, C), the initialization process, Libuv’s event‑loop phases, task scheduling, I/O models, and how Node.js maintains non‑blocking, concurrent connections.

Backend DevelopmentNode.jsTCP
0 likes · 35 min read
Node.js TCP Connections Explained: Event Loop & Libuv Architecture
Liangxu Linux
Liangxu Linux
Feb 22, 2023 · Fundamentals

Why Does a TCP Client Send RST When SYN‑ACK Ack Number Mismatches?

The article explains that during TCP's three‑way handshake, if a client receives a SYN‑ACK with an unexpected acknowledgment number, it must send an RST to abort the stale connection, because silently discarding the packet would cause long retransmission delays and prevent the new connection from being established.

Connection ResetRSTSYN-ACK
0 likes · 5 min read
Why Does a TCP Client Send RST When SYN‑ACK Ack Number Mismatches?
Open Source Linux
Open Source Linux
Feb 16, 2023 · Fundamentals

Why HTTP Was Designed That Way: From TCP Basics to HTTP/3 Evolution

An in‑depth look at HTTP’s origins, its client‑driven request‑response design, the evolution of headers, length‑ and delimiter‑based streams, and the successive enhancements from HTTP/0.9 through HTTP/1.1 to HTTP/2, SPDY, and HTTP/3, explaining the motivations behind each change.

HTTPHTTP/2HTTP/3
0 likes · 28 min read
Why HTTP Was Designed That Way: From TCP Basics to HTTP/3 Evolution
Efficient Ops
Efficient Ops
Jan 29, 2023 · Operations

How Linux Kernel Handles TCP Connections: Deep Dive into sock_common and Lookup

This article explores Linux kernel TCP connection handling by examining socket data structures, port range and file descriptor tuning, core functions like tcp_v4_rcv, and lookup mechanisms, while offering practical tips to boost client-side concurrent connections beyond traditional limits.

Linux kernelOperationsPerformance Tuning
0 likes · 9 min read
How Linux Kernel Handles TCP Connections: Deep Dive into sock_common and Lookup
Liangxu Linux
Liangxu Linux
Jan 12, 2023 · Operations

How to Diagnose and Reduce Linux Network Latency with hping3, wrk, and Wireshark

This article explains the fundamentals of Linux network latency, demonstrates how to measure round‑trip time using ping, traceroute, hping3 and wrk, walks through a Docker‑based test setup, and shows how to analyze packet captures with tcpdump and Wireshark to uncover causes such as TCP delayed ACK.

LinuxTCPTroubleshooting
0 likes · 15 min read
How to Diagnose and Reduce Linux Network Latency with hping3, wrk, and Wireshark
Open Source Linux
Open Source Linux
Jan 9, 2023 · Fundamentals

Why TCP Matters: A Deep Dive into Reliable Transport and Network Layers

This article explains the essential concepts of TCP and UDP, covering the OSI model layers, socket communication, reliable transmission mechanisms such as stop‑and‑wait and sliding‑window, congestion control, connection establishment, and practical differences between TCP and UDP, providing a comprehensive networking fundamentals overview.

Congestion ControlReliabilityTCP
0 likes · 26 min read
Why TCP Matters: A Deep Dive into Reliable Transport and Network Layers
Ops Development Stories
Ops Development Stories
Dec 28, 2022 · Fundamentals

HTTP Keep-Alive vs TCP Keepalive: Key Differences Explained

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.

HTTPKeep-AliveTCP
0 likes · 8 min read
HTTP Keep-Alive vs TCP Keepalive: Key Differences Explained
Architect's Guide
Architect's Guide
Dec 25, 2022 · Fundamentals

Understanding TCP Connection Limits and the Role of Port Numbers

The article explains how TCP connections are identified by a four‑tuple, clarifies the theoretical maximum of 65,535 client ports versus the far larger possible server connections, and discusses practical limits imposed by memory, file descriptors, and system configuration on Linux servers.

LinuxPort NumbersSocket
0 likes · 10 min read
Understanding TCP Connection Limits and the Role of Port Numbers
Open Source Linux
Open Source Linux
Dec 19, 2022 · Fundamentals

Master the TCP/IP Stack: From Layers to Real-World Protocols

This comprehensive guide explains the TCP/IP model’s four layers, key protocols such as IP, ARP, ICMP, DNS, and the differences between TCP and UDP, and details connection setup, termination, flow and congestion control mechanisms like slow start, fast retransmit, and fast recovery.

Congestion ControlTCPTCP/IP
0 likes · 23 min read
Master the TCP/IP Stack: From Layers to Real-World Protocols
Liangxu Linux
Liangxu Linux
Dec 14, 2022 · Fundamentals

Unraveling TCP: From Physical Wires to Reliable Data Streams

This article provides a comprehensive, step‑by‑step explanation of TCP and related transport‑layer concepts, covering the OSI model, physical to application layers, socket and port mechanics, TCP header fields, reliable transmission techniques, flow and congestion control, connection setup/teardown, and a brief comparison with UDP.

Congestion ControlReliable TransmissionTCP
0 likes · 28 min read
Unraveling TCP: From Physical Wires to Reliable Data Streams
Thoughts on Knowledge and Action
Thoughts on Knowledge and Action
Dec 2, 2022 · Fundamentals

Understanding TCP: Basics, Handshakes, Flags, and Performance Tuning

This article explains TCP fundamentals—including connection-oriented design, byte‑stream transmission, reliability, header structure, flag meanings, the three‑way handshake, four‑way termination, SYN‑Flood attacks, time‑wait handling, retransmission strategies, kernel tuning parameters, Nagle’s algorithm, and congestion control mechanisms such as slow start and congestion avoidance.

Congestion ControlLinuxRetransmission
0 likes · 12 min read
Understanding TCP: Basics, Handshakes, Flags, and Performance Tuning
Su San Talks Tech
Su San Talks Tech
Dec 1, 2022 · Fundamentals

Master Computer Networks: From OSI Layers to TCP Handshakes and Security Essentials

This comprehensive guide covers computer network fundamentals, including OSI and TCP/IP models, protocol layers, DNS resolution, HTTP/HTTPS details, TCP three‑way handshake and four‑way teardown, congestion control, security threats like XSS and CSRF, and practical mitigation techniques, providing a solid foundation for networking interviews and real‑world applications.

Computer NetworksDNSHTTP
0 likes · 71 min read
Master Computer Networks: From OSI Layers to TCP Handshakes and Security Essentials
Su San Talks Tech
Su San Talks Tech
Nov 12, 2022 · Fundamentals

When Is UDP Faster Than TCP? Deep Dive into Socket Protocols

While UDP is often assumed to be faster than TCP, this article explains socket basics, the reliability mechanisms of TCP, scenarios where UDP can be slower, and how application-layer solutions like KCP or QUIC add reliability, helping readers understand when each protocol truly excels.

Congestion ControlNetwork ProtocolsPacket loss
0 likes · 13 min read
When Is UDP Faster Than TCP? Deep Dive into Socket Protocols
Open Source Linux
Open Source Linux
Oct 31, 2022 · Fundamentals

Mastering TCP Retransmission: Timeout, Fast Retransmit, SACK, and Congestion Control

This article explains TCP's retransmission mechanisms—including timeout retransmission, fast retransmit, SACK and D‑SACK—along with sliding window operation, window sizing, and congestion control algorithms such as slow start, congestion avoidance, and fast recovery, providing a comprehensive network fundamentals guide.

Congestion ControlRetransmissionSACK
0 likes · 12 min read
Mastering TCP Retransmission: Timeout, Fast Retransmit, SACK, and Congestion Control
Efficient Ops
Efficient Ops
Oct 17, 2022 · Fundamentals

Master the TCP/IP Model: From Layers to Real-World Protocols

This comprehensive guide explains the TCP/IP protocol suite, detailing each of its four layers, key protocols such as IP, TCP, UDP, ICMP, ARP, and DNS, and illustrates essential mechanisms like encapsulation, three‑way handshake, flow control, congestion control, and tools like ping and traceroute.

TCPTCP/IPUDP
0 likes · 24 min read
Master the TCP/IP Model: From Layers to Real-World Protocols
Refining Core Development Skills
Refining Core Development Skills
Sep 21, 2022 · Fundamentals

Deep Understanding of Linux Networking – Key Q&A Highlights

This article summarizes a series of technical Q&A from an OSChina event covering Linux networking fundamentals such as port limits, network namespaces, TCP connection handling, C10K problem, packet loss troubleshooting, TCP memory usage, high CPU causes, useful monitoring tools, kernel parameters, and practical socket examples.

LinuxPerformanceSockets
0 likes · 12 min read
Deep Understanding of Linux Networking – Key Q&A Highlights
Efficient Ops
Efficient Ops
Sep 15, 2022 · Operations

How to Diagnose and Fix Linux Network Latency Issues

This article explains how to identify the root causes of increased network latency on Linux servers, covering tools such as ping, traceroute, hping3, and wrk, demonstrating packet analysis with tcpdump and Wireshark, and showing how TCP delayed ACK and socket options affect response times.

TCPTroubleshootingWireshark
0 likes · 17 min read
How to Diagnose and Fix Linux Network Latency Issues
政采云技术
政采云技术
Sep 13, 2022 · Fundamentals

Understanding TCP Keepalive Mechanism and Its Parameters

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.

LinuxSocketTCP
0 likes · 11 min read
Understanding TCP Keepalive Mechanism and Its Parameters
High Availability Architecture
High Availability Architecture
Sep 7, 2022 · Backend Development

Analysis and Optimization of HttpClient Connection Management in High‑Concurrency Scenarios

The article investigates frequent HttpClient connection‑pool exhaustion caused by excessive CLOSE_WAIT sockets in a high‑traffic Java service, explains the underlying TCP and HttpClient mechanisms, presents diagnostic commands and code snippets, and offers concrete configuration and architectural recommendations to prevent similar issues.

ConnectionPoolingHttpClientPerformance
0 likes · 16 min read
Analysis and Optimization of HttpClient Connection Management in High‑Concurrency Scenarios
Liangxu Linux
Liangxu Linux
Sep 4, 2022 · Fundamentals

What Happens When TCP Handshake or Teardown Packets Are Lost?

This article explains how TCP connections behave when any of the three-way handshake or four-way termination packets are lost, detailing the kernel‑controlled retransmission mechanisms, timeout intervals, relevant sysctl parameters, and the exact sequence of events for each loss scenario.

Four-way terminationLinuxNetwork
0 likes · 13 min read
What Happens When TCP Handshake or Teardown Packets Are Lost?
Open Source Linux
Open Source Linux
Sep 1, 2022 · Fundamentals

How to Debug TCP Throughput Bottlenecks: rwnd, cwnd, and Wireshark Tips

This guide explains how to identify and troubleshoot TCP throughput limitations by examining sender, receiver, and network bottlenecks, understanding rwnd and cwnd values, using Linux tools like ss and Wireshark, and interpreting packet traces to pinpoint congestion or loss.

LinuxTCPThroughput Debugging
0 likes · 11 min read
How to Debug TCP Throughput Bottlenecks: rwnd, cwnd, and Wireshark Tips
Liangxu Linux
Liangxu Linux
Aug 31, 2022 · Operations

Why TIME_WAIT Connections Accumulate and How to Fix Them

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.

LinuxOperationsSocket
0 likes · 8 min read
Why TIME_WAIT Connections Accumulate and How to Fix Them
Open Source Linux
Open Source Linux
Aug 17, 2022 · Operations

Mastering TCP States: Diagnose Network Issues with Linux Tools

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.

LinuxSocketTCP
0 likes · 31 min read
Mastering TCP States: Diagnose Network Issues with Linux Tools
Efficient Ops
Efficient Ops
Aug 15, 2022 · Fundamentals

Why Does TIME_WAIT Accumulate in High‑Concurrency Scenarios and How to Fix It?

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.

High concurrencyTCPTIME_WAIT
0 likes · 7 min read
Why Does TIME_WAIT Accumulate in High‑Concurrency Scenarios and How to Fix It?
Architecture Digest
Architecture Digest
Aug 12, 2022 · Fundamentals

Differences and Principles of TCP and UDP Protocols

This article explains the fundamental differences between TCP and UDP, covering their purposes, reliability, speed, handshake mechanisms, data transmission processes, and termination procedures, and includes visual diagrams to illustrate each concept in.

Data TransmissionHandshakeTCP
0 likes · 10 min read
Differences and Principles of TCP and UDP Protocols
Liangxu Linux
Liangxu Linux
Aug 8, 2022 · Backend Development

Why RPC Still Matters When HTTP Exists: A Deep Dive into TCP, HTTP, and RPC

This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.

HTTPRPCTCP
0 likes · 13 min read
Why RPC Still Matters When HTTP Exists: A Deep Dive into TCP, HTTP, and RPC