BestHub
Sign in
Tagged articles

Netty

352 articles · Page 1 of 4
Ray's Galactic Tech
Ray's Galactic Tech
Aug 4, 2026 · Backend Development

Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design

This guide walks through building a high‑performance, scalable MQTT access gateway for IoT using Spring Boot for service orchestration and Netty for connection handling, covering protocol fundamentals, modular architecture, multi‑protocol adaptation, session management, high‑concurrency optimizations, clustering, observability, and deployment best practices.

IoTKubernetesMQTT
0 likes · 40 min read
Spring Boot & Netty MQTT Platform: Multi‑Protocol and Modular Design
Mike Chen Rui
Mike Chen Rui
Jul 29, 2026 · Backend Development

How Spring Cloud Gateway Handles Tens of Millions QPS

The article explains how Spring Cloud Gateway achieves ultra‑high QPS by leveraging Netty's non‑blocking I/O, Project Reactor's event‑driven streams with backpressure, and lightweight route predicates combined with load‑balancing to maximize thread utilization and system throughput.

API GatewayLoad BalancingNetty
0 likes · 4 min read
How Spring Cloud Gateway Handles Tens of Millions QPS
Java Architect Handbook
Java Architect Handbook
Jul 22, 2026 · Backend Development

Why Netty Is the Ideal Choice for Java Network Programming – Interview Insights

The article explains why Netty outperforms raw JDK NIO for network programming by detailing NIO's pain points, Netty's elegant Reactor design, zero‑copy and memory‑pool optimizations, built‑in codecs and pipeline, bug fixes, and its extensive ecosystem, all framed as interview knowledge.

ChannelPipelineHigh-performance networkingJava NIO
0 likes · 14 min read
Why Netty Is the Ideal Choice for Java Network Programming – Interview Insights
Ray's Galactic Tech
Ray's Galactic Tech
Jul 14, 2026 · Cloud Native

Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push

To support millions of persistent MQTT connections with sub‑millisecond latency, the article walks through a Spring Boot + Netty cloud‑native gateway design that separates connection, event, state and governance planes, details async authentication, back‑pressure handling, command state machines, and loss‑less Kubernetes roll‑outs.

Cloud NativeGatewayKafka
0 likes · 38 min read
Spring Boot + Netty MQTT Gateway for Million Connections & Millisecond Push
Tech Musings
Tech Musings
Jul 7, 2026 · Operations

Avoid Cloud TCP KeepAlive Pitfalls with Simple Linux Kernel Tweaks

The article explains why the default 7200‑second TCP KeepAlive idle time causes RSTs in cloud environments, demonstrates Netty configuration for finer‑grained keepalive settings, shares real‑world cloud‑networking failures, and recommends adjusting Linux kernel parameters as a reliable solution.

LinuxNettyNetworking
0 likes · 6 min read
Avoid Cloud TCP KeepAlive Pitfalls with Simple Linux Kernel Tweaks
Niu Liu
Niu Liu
Jul 5, 2026 · Databases

How to Build a MySQL Protocol Server from Scratch for the DSP Database

This article walks through the complete implementation of a MySQL‑compatible front‑end protocol in the DSP (Sloth) database, covering why MySQL compatibility matters, Netty pipeline design, packet framing, three‑step handshake, two‑level command routing, result‑set encoding, length‑encoded integers, variable substitution, and current limitations.

DSP DatabaseLengthEncodedIntegerMySQL Protocol
0 likes · 10 min read
How to Build a MySQL Protocol Server from Scratch for the DSP Database
Tech Musings
Tech Musings
Jun 14, 2026 · Backend Development

Does Netty’s io_uring Make the 2× CPU Thread Rule Obsolete?

A benchmark on an 8‑core Linux 6.6 system shows that switching Netty from epoll to io_uring lets a half‑sized thread pool achieve 3 % higher throughput, more than double per‑thread efficiency, and a 67 % reduction in CPU migrations, challenging the traditional rule of using twice‑the‑core thread counts.

Nettybenchmarkepoll
0 likes · 21 min read
Does Netty’s io_uring Make the 2× CPU Thread Rule Obsolete?
Cloud Architecture
Cloud Architecture
Jun 10, 2026 · Backend Development

Million-Connection Single-Server with Netty: Architecture, Extreme Tuning, and Production Deployment

This article details how to design and tune a Netty‑based single‑machine gateway capable of handling one million concurrent TCP long‑connections, covering network model, memory management, protocol design, OS and JVM optimizations, clustering, load balancing, graceful shutdown, monitoring, and practical deployment considerations.

Long ConnectionsNettyServer Architecture
0 likes · 43 min read
Million-Connection Single-Server with Netty: Architecture, Extreme Tuning, and Production Deployment
Java Tech Workshop
Java Tech Workshop
May 29, 2026 · Backend Development

Why Use Spring Cloud Gateway? A Beginner’s Guide to Building a SpringBoot API Gateway

In a micro‑service architecture, a centralized gateway eliminates the need for front‑ends to call dozens of services by handling authentication, rate‑limiting, logging, CORS, and security, and Spring Cloud Gateway—built on WebFlux and Netty—offers a non‑blocking, high‑throughput alternative to Zuul with detailed configuration and code examples for production use.

API GatewayMicroservicesNetty
0 likes · 18 min read
Why Use Spring Cloud Gateway? A Beginner’s Guide to Building a SpringBoot API Gateway
Sohu Tech Products
Sohu Tech Products
May 27, 2026 · Backend Development

IDEA + JavaAI: A Hands‑On Review of Building a Mini‑Redis Spring Boot Starter

After struggling with AI‑generated code that failed on global edge cases, the author evaluates the FeiSuan JavaAI IDEA plugin, walking through its five‑agent workflow—from requirement planning to source generation—and demonstrates how it successfully creates a production‑ready mini‑redis Spring Boot starter with thorough testing.

AI code generationAgentIDEA
0 likes · 16 min read
IDEA + JavaAI: A Hands‑On Review of Building a Mini‑Redis Spring Boot Starter
IoT Full-Stack Technology
IoT Full-Stack Technology
May 26, 2026 · Backend Development

Build a Real‑Time Message Push Service with Spring Boot, Netty and WebSocket

This article walks through creating a Netty‑based WebSocket server integrated with Spring Boot, covering server bootstrap, global channel management, pipeline configuration, a custom handler for client messages, and a push‑message service that can target individual users or broadcast to all connections, complete with code samples and testing steps.

Message PushNettySpring Boot
0 likes · 6 min read
Build a Real‑Time Message Push Service with Spring Boot, Netty and WebSocket
Java Architect Handbook
Java Architect Handbook
May 25, 2026 · Fundamentals

Interview Torture: What Are TCP Sticky/Unsticky Packet Issues and Why They Matter

The article explains that TCP's byte‑stream nature causes sticky and unpacked packet problems, analyzes why they occur, compares UDP, and presents four application‑layer solutions—especially the Header‑Body length‑field approach used by Netty—providing code examples and interview‑ready answers.

InterviewLengthFieldBasedFrameDecoderNetty
0 likes · 14 min read
Interview Torture: What Are TCP Sticky/Unsticky Packet Issues and Why They Matter
IoT Full-Stack Technology
IoT Full-Stack Technology
May 25, 2026 · Backend Development

Practical Spring Boot + Netty + WebSocket Message Push

This article walks through building a simple Netty server integrated with Spring Boot and WebSocket, showing how to configure the server, manage channel groups, implement custom handlers, and expose a service that can push messages to individual users or broadcast to all connected clients.

Message PushNettySpring Boot
0 likes · 8 min read
Practical Spring Boot + Netty + WebSocket Message Push
Architect's Guide
Architect's Guide
Apr 29, 2026 · Backend Development

How to Use Spring Boot, Netty, and WebSocket for Server‑to‑Client Push

This article walks through building a Netty‑based WebSocket server integrated with Spring Boot, configuring the channel pipeline, implementing custom handlers, exposing a push‑message service, and testing the end‑to‑end flow that enables the backend to push real‑time messages to web clients.

NettyServer PushSpring Boot
0 likes · 8 min read
How to Use Spring Boot, Netty, and WebSocket for Server‑to‑Client Push
Architect Chen
Architect Chen
Apr 13, 2026 · Backend Development

How to Make Spring Cloud Gateway Handle a Million Concurrent Requests

This article explains how Spring Cloud Gateway leverages a reactive, non‑blocking architecture, OS‑level tuning, zero‑copy networking, and built‑in rate‑limiting and circuit‑breaker features to reliably sustain million‑level concurrent traffic in production environments.

NettyReactiveSpring Cloud Gateway
0 likes · 4 min read
How to Make Spring Cloud Gateway Handle a Million Concurrent Requests
LuTiao Programming
LuTiao Programming
Jan 11, 2026 · Backend Development

Beyond HTTP: Building a Custom TCP Protocol with Spring Boot and Netty from Scratch

This article walks through why raw ServerSocket code is unsuitable for high‑concurrency custom protocols, explains Netty’s event‑driven architecture, and provides a step‑by‑step Spring Boot integration—including Maven setup, boss/worker groups, pipeline configuration, a ByteToMessageDecoder for a 49‑byte binary format, and a business handler—to achieve a clean, maintainable TCP solution.

Custom TCP ProtocolDevice CommunicationJava NIO
0 likes · 9 min read
Beyond HTTP: Building a Custom TCP Protocol with Spring Boot and Netty from Scratch
Ray's Galactic Tech
Ray's Galactic Tech
Jan 7, 2026 · Backend Development

Why Netty Servers Accumulate CLOSE_WAIT Connections and How to Fix Them

Netty services can accumulate CLOSE_WAIT sockets when the server fails to close its side of the socket, leading to resource exhaustion and potential service collapse; this article explains the TCP state machine, common code pitfalls, kernel tuning, defensive handlers, and a comprehensive checklist to prevent and resolve the issue.

CLOSE_WAITConnection ManagementNetty
0 likes · 8 min read
Why Netty Servers Accumulate CLOSE_WAIT Connections and How to Fix Them
Dunmao Tech Hub
Dunmao Tech Hub
Dec 14, 2025 · Backend Development

Integrating Netty into Spring Boot for Custom Protocol Support

This guide explains how to embed the Netty framework within a Spring Boot application to handle custom protocols, covering Netty basics, Maven dependencies, server bootstrap configuration, custom decoder implementation, and event handler setup for robust, high‑performance asynchronous communication.

NettySpringBootbackend development
0 likes · 13 min read
Integrating Netty into Spring Boot for Custom Protocol Support
Architecture Digest
Architecture Digest
Dec 10, 2025 · Backend Development

How to Build a Mini Didi: Scalable Ride‑Hailing Architecture Explained

This article dissects the core architecture of a miniature ride‑hailing platform, covering domain‑driven design, layered microservice structure, Redis GEO for fast location queries, distributed locking, Netty‑based real‑time messaging, and hot‑cold data separation to handle massive traffic and ensure reliability.

NettyRedis GEORide Hailing
0 likes · 8 min read
How to Build a Mini Didi: Scalable Ride‑Hailing Architecture Explained
Java Architect Handbook
Java Architect Handbook
Dec 6, 2025 · Backend Development

Mastering Netty: From IO Models to a Real‑Time Chat Service

This article explains Netty’s architecture, compares Java’s BIO/NIO/AIO models, describes its thread models and pipeline, and provides a step‑by‑step guide with code to build a WebSocket‑based real‑time chat server using Spring Boot 3 and JDK 21.

NettyReal-time Chatbackend development
0 likes · 21 min read
Mastering Netty: From IO Models to a Real‑Time Chat Service
Selected Java Interview Questions
Selected Java Interview Questions
Dec 2, 2025 · Backend Development

How to Build a Scalable WebSocket Service with Netty, Spring Boot, and Vue2

This guide walks through creating a full‑stack WebSocket solution using Netty for the server, Spring Boot for lifecycle management, Redis for token validation, and Vue2 on the client, covering configuration, token handling, heartbeat detection, channel management, and message broadcasting with complete code examples.

NettyReal-time messagingSpring Boot
0 likes · 37 min read
How to Build a Scalable WebSocket Service with Netty, Spring Boot, and Vue2
Java Companion
Java Companion
Nov 16, 2025 · Backend Development

Stunning Architecture Designs Inside XXL-JOB Explained

The article dissects XXL-JOB's communication layer, showcasing Netty HTTP usage, a full asynchronous processing pipeline, dynamic proxy abstraction, request‑ID based thread wake‑up, and detailed Java code examples that illustrate how the scheduler and executor achieve high‑throughput remote job execution.

Dynamic ProxyNettyRPC
0 likes · 7 min read
Stunning Architecture Designs Inside XXL-JOB Explained
Architect
Architect
Oct 8, 2025 · Backend Development

How xxl-job Leverages Netty and Dynamic Proxies for High‑Throughput Asynchronous RPC

This article explains how xxl-job employs Netty HTTP, dynamic proxy patterns, and fully asynchronous processing to achieve efficient remote procedure calls, detailing the communication layer, overall workflow, key design points, and the underlying Java code that synchronously retrieves results from asynchronous operations.

AsynchronousDynamic ProxyNetty
0 likes · 7 min read
How xxl-job Leverages Netty and Dynamic Proxies for High‑Throughput Asynchronous RPC
Architect
Architect
Oct 3, 2025 · Backend Development

How to Build a Scalable Netty TCP Client with Redis Queue and Spring Boot

This article walks through a complete Netty TCP client demo for IoT messaging, covering project architecture, module layout, business flow, detailed code explanations—including a local BlockingQueue replacement for RocketMQ, thread‑safe client creation with Redis locks, and testing endpoints—providing a practical reference for building robust socket‑based services.

IoTNettyRedis
0 likes · 20 min read
How to Build a Scalable Netty TCP Client with Redis Queue and Spring Boot
Sohu Smart Platform Tech Team
Sohu Smart Platform Tech Team
Sep 26, 2025 · Backend Development

Why Does My Spring Boot App Crash While Netty Still Runs? A Deep Dive

During a gray‑release a single server reported that the Spring container was closed while the Netty server still accepted HTTP requests, leading to an IllegalStateException; the article analyzes the root cause in Dubbo startup, explains the event flow, and proposes a reliable fix using ApplicationReadyEvent.

ApplicationReadyEventContextRefreshedEventDubbo
0 likes · 7 min read
Why Does My Spring Boot App Crash While Netty Still Runs? A Deep Dive
Lin is Dream
Lin is Dream
Aug 29, 2025 · Backend Development

How I Built a Mini‑Netty from Scratch: Lessons in Java NIO Design

This article concludes the "From Zero Hand‑write Mini Netty" series, walking through the evolution from a simple single‑thread NIO program to a multi‑threaded, pluggable Mini‑Netty framework with heartbeat, decoding, and responsibility‑chain processing, and outlines future plans for a full‑featured Netty chat application.

Mini FrameworkNIONetty
0 likes · 7 min read
How I Built a Mini‑Netty from Scratch: Lessons in Java NIO Design
Lin is Dream
Lin is Dream
Aug 25, 2025 · Backend Development

How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic

This article explains how to redesign a Java NIO server by introducing a Netty‑style pipeline that separates decoding, logging, authentication, and business handling into independent handlers, improving extensibility, maintainability, and performance while providing complete sample code and initialization steps.

Design PatternsNettyhandler
0 likes · 15 min read
How to Build a Mini‑Netty Pipeline that Decouples Decoding from Business Logic
FunTester
FunTester
Aug 24, 2025 · Backend Development

How to Tackle the C10K Challenge: High‑Concurrency Tips for Java/Netty Servers

This article explains the C10K problem and provides practical, non‑blocking and reactive strategies, thread‑count minimization, Netty configuration, memory management, and emerging technologies like GraalVM Native‑Image and Project Loom to keep Java servers stable under massive concurrent connections.

C10KGraalVMJava performance
0 likes · 10 min read
How to Tackle the C10K Challenge: High‑Concurrency Tips for Java/Netty Servers
Lin is Dream
Lin is Dream
Aug 22, 2025 · Backend Development

Mastering Asynchronous Writes in Java NIO: Build a Reliable Write Queue

This article explains why direct writes to a Java NIO channel fail for large messages, introduces a write‑queue and OP_WRITE listener to handle partial writes, and provides a complete PacketWriter implementation that transforms synchronous writes into efficient asynchronous operations.

Java NIONettySocketChannel
0 likes · 9 min read
Mastering Asynchronous Writes in Java NIO: Build a Reliable Write Queue
Wukong Talks Architecture
Wukong Talks Architecture
Aug 14, 2025 · Backend Development

Understanding RocketMQ Architecture: Components, Protocols, and Storage

This article provides a comprehensive overview of RocketMQ's architecture, detailing its core components, network protocols, storage mechanisms, producer‑consumer workflow, and transactional messaging, while highlighting differences between Remoting and gRPC and explaining key design choices for high performance and reliability.

Message QueueNettyRocketMQ
0 likes · 15 min read
Understanding RocketMQ Architecture: Components, Protocols, and Storage
Programmer1970
Programmer1970
Jul 25, 2025 · Backend Development

Netty Performance Tuning: Zero‑Copy, Off‑Heap Memory Management, and EventLoop Thread Model Optimization

This article analyzes the root causes of high CPU usage, GC pauses, and thread contention in Netty‑based messaging systems and presents a step‑by‑step solution covering zero‑copy with CompositeByteBuf and FileRegion, off‑heap Direct Buffers with PooledByteBufAllocator, and fine‑tuned EventLoopGroup configurations, backed by concrete benchmark data.

Java NIONettyOff-heap memory
0 likes · 11 min read
Netty Performance Tuning: Zero‑Copy, Off‑Heap Memory Management, and EventLoop Thread Model Optimization
Java Captain
Java Captain
Jul 6, 2025 · Backend Development

Why Choose Netty Over Java NIO? A Hands‑On Guide with Server‑Client Demo

This article explains why using raw Java NIO for network communication is problematic, highlights Netty's advantages such as simplified APIs, high performance, and extensive adoption, and provides a complete server‑client demo with detailed code and design insights.

Java NIONettyReactor pattern
0 likes · 14 min read
Why Choose Netty Over Java NIO? A Hands‑On Guide with Server‑Client Demo
Architect's Must-Have
Architect's Must-Have
Jun 9, 2025 · Backend Development

Why Netty Introduced FastThreadLocal and How It Boosts Performance

FastThreadLocal, Netty’s custom thread‑local implementation, replaces JDK’s ThreadLocal by using an indexed array to avoid hash collisions, offering faster access; this article explains its background, core classes, source‑code mechanics, performance trade‑offs, and cleanup strategies within Netty’s architecture.

FastThreadLocalNettyThreadLocal
0 likes · 13 min read
Why Netty Introduced FastThreadLocal and How It Boosts Performance
Tech Freedom Circle
Tech Freedom Circle
May 28, 2025 · Backend Development

Designing a 100k QPS Sensitive‑Word Filter with Real‑Time Updates

This article analyzes high‑throughput sensitive‑word filtering by comparing brute‑force, KMP, Trie, double‑array Trie and Aho‑Corasick algorithms, presents their time and space complexities, shows Java implementations for Trie and AC automata, evaluates Netty deployment options, and offers practical optimizations such as asynchronous detection, hot‑reloading, tiered responses, logging and fuzzy matching.

Aho-CorasickKMPNetty
0 likes · 37 min read
Designing a 100k QPS Sensitive‑Word Filter with Real‑Time Updates
FunTester
FunTester
May 24, 2025 · Backend Development

How to Stress-Test Netty WebSocket for 10,000 Subscriptions and Keepalive

This article presents advanced WebSocket testing techniques—including asynchronous connection creation, result statistics, price verification, latency measurement, TPS modeling—and demonstrates a Netty‑WebSocket subscription test for 10,000 users plus Java‑ and Netty‑based keepalive implementations for high‑concurrency scenarios.

NettyPerformance Testingconcurrency
0 likes · 7 min read
How to Stress-Test Netty WebSocket for 10,000 Subscriptions and Keepalive
FunTester
FunTester
May 18, 2025 · Backend Development

Building a High‑Performance Netty WebSocket Client for Large‑Scale Performance Testing

This article explains how to build a high‑performance Netty‑based WebSocket client for large‑scale performance testing, covering Netty fundamentals, custom handler implementation, client bootstrap configuration, message sending, connection closing, batch operations, and client encapsulation to reduce resource consumption and improve scalability.

NettyPerformance Testingbackend
0 likes · 14 min read
Building a High‑Performance Netty WebSocket Client for Large‑Scale Performance Testing
Java Backend Technology
Java Backend Technology
May 15, 2025 · Backend Development

Why Netty Uses FastThreadLocal Over JDK ThreadLocal: Deep Dive & Code Analysis

This article explains why Netty introduces FastThreadLocal instead of relying on JDK ThreadLocal, detailing its background, core principles, source code structure—including InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal implementations—performance implications, resource reclamation mechanisms, and practical usage within Netty’s memory allocation.

FastThreadLocalMemory ManagementNetty
0 likes · 11 min read
Why Netty Uses FastThreadLocal Over JDK ThreadLocal: Deep Dive & Code Analysis
Architect
Architect
Apr 25, 2025 · Backend Development

Building a High‑Performance Real‑Time Communication System with Netty and Spring Boot 3

This article explains Netty's asynchronous architecture, compares BIO/NIO/AIO models, describes its thread and pipeline designs, evaluates real‑time communication options, and provides complete frontend and backend code examples for creating a WebSocket‑based instant messaging service using Netty and Spring Boot 3.

NettyReal‑time communicationbackend development
0 likes · 18 min read
Building a High‑Performance Real‑Time Communication System with Netty and Spring Boot 3
Cognitive Technology Team
Cognitive Technology Team
Apr 17, 2025 · Backend Development

Understanding and Solving NIO Empty Polling in Java with Netty

This article explains the root causes of Java NIO empty polling, its impact on CPU usage, and presents Netty's multi‑layer detection, threshold‑based auto‑rebuild, and selector reconstruction techniques, along with configuration tips and future optimization directions for high‑concurrency backend systems.

EmptyPollingNIONetty
0 likes · 8 min read
Understanding and Solving NIO Empty Polling in Java with Netty
Sohu Tech Products
Sohu Tech Products
Apr 16, 2025 · Operations

1. Architecture Overview

Drawing on experience with TimerTask, Quartz, SpringTask, HashWheelTimer, Elastic‑Job, XXL‑JOB, and AirFlow, the author created a teaching‑focused, horizontally scalable task‑scheduling platform supporting over 100 000 jobs, organized into gateway, admin, and worker layers, with a detailed architecture and tech‑stack overview.

NettyQuartzarchitecture
0 likes · 6 min read
1. Architecture Overview
Cognitive Technology Team
Cognitive Technology Team
Apr 11, 2025 · Backend Development

Understanding Netty 4 Thread Model: Master‑Worker Multithreading and EventLoop Design

Netty 4 employs a global multithreaded, locally single‑threaded (event‑loop) architecture where a boss thread pool accepts connections and delegates them to worker thread pools, each containing NioEventLoop instances with selectors, task queues, and pipelines, ensuring lock‑free, ordered processing while avoiding thread blocking.

EventLoopNettyThread Model
0 likes · 5 min read
Understanding Netty 4 Thread Model: Master‑Worker Multithreading and EventLoop Design
Architect's Must-Have
Architect's Must-Have
Mar 18, 2025 · Backend Development

Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal

This article explains the motivation behind Netty's FastThreadLocal, details its internal design using an indexed array to avoid hash collisions, analyzes the core source code of InternalThreadLocalMap, FastThreadLocalThread, and FastThreadLocal, and discusses performance implications and reclamation strategies.

FastThreadLocalMemory ManagementNetty
0 likes · 10 min read
Why Netty Uses FastThreadLocal and How It Outperforms JDK ThreadLocal
Lin is Dream
Lin is Dream
Mar 17, 2025 · Backend Development

How Web Containers Stay Alive: Inside Java Servlets, Netty, and Sockets

Web containers, such as Tomcat, keep running by continuously listening on network ports with socket servers and thread pools, handling I/O requests; this article explains the role of the main function, servlet lifecycle, Netty’s NIO framework, and why WebFlux‑based gateways outperform traditional Tomcat setups.

NettyServletSpring WebFlux
0 likes · 5 min read
How Web Containers Stay Alive: Inside Java Servlets, Netty, and Sockets
Alibaba Cloud Developer
Alibaba Cloud Developer
Feb 26, 2025 · Fundamentals

Why Did Upgrading to JDK 11 Spike Direct Memory Usage? A Deep Dive

This article records and analyzes how upgrading an application to JDK 11 changed the Direct Memory management strategy, causing a sharp increase in memory‑utilization alerts, and demonstrates step‑by‑step troubleshooting, code inspection, and JVM parameter tuning to restore normal memory usage.

DirectMemoryJDK11MemoryManagement
0 likes · 16 min read
Why Did Upgrading to JDK 11 Spike Direct Memory Usage? A Deep Dive
Top Architect
Top Architect
Jan 16, 2025 · Backend Development

Guide to Using the XXL‑JOB Distributed Task Scheduling Framework with Spring Boot

This article introduces the XXL‑JOB open‑source distributed scheduler, compares it with Quartz and other solutions, and provides a step‑by‑step tutorial for server deployment, executor configuration, task development, execution, logging, and the underlying Netty‑based communication design, complete with code examples.

NettySpring BootXXL-JOB
0 likes · 15 min read
Guide to Using the XXL‑JOB Distributed Task Scheduling Framework with Spring Boot
Dangbei Technology Team
Dangbei Technology Team
Dec 31, 2024 · Backend Development

How WebSocket Powers Real-Time IoT Devices: Architecture & Code Walkthrough

This article explores the role of WebSocket in IoT, detailing its advantages over HTTP, comparing Java implementations, presenting a Netty‑based architecture for smart devices, and providing complete code examples for connection handling, authentication, and message processing to achieve real‑time communication.

IoTNettyReal‑time communication
0 likes · 12 min read
How WebSocket Powers Real-Time IoT Devices: Architecture & Code Walkthrough
Bin's Tech Cabin
Bin's Tech Cabin
Dec 25, 2024 · Backend Development

Unveiling Netty and Kafka Time Wheels: High‑Performance Scheduling Explained

This article explores the design and implementation of time wheel algorithms in Netty and Kafka, comparing their single‑layer and multi‑layer approaches, analyzing performance trade‑offs, and detailing how these systems achieve O(1) scheduling for massive delayed tasks while avoiding empty ticks.

KafkaNettyScheduling
0 likes · 76 min read
Unveiling Netty and Kafka Time Wheels: High‑Performance Scheduling Explained
DaTaobao Tech
DaTaobao Tech
Dec 11, 2024 · Backend Development

Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade

After upgrading core services to JDK 11, the team encountered a Metaspace rise and off‑heap memory growth caused by class‑loading changes and Netty’s disabled native buffers, which were resolved by expanding Metaspace to 768 MB and adding JVM options to enable Netty reflection and open required modules, restoring normal memory usage.

JDK11JVMMemoryLeak
0 likes · 8 min read
Resolving Metaspace and Off‑Heap Memory Issues After JDK 11 Upgrade
Code Ape Tech Column
Code Ape Tech Column
Dec 4, 2024 · Backend Development

Deep Dive into Netty’s Asynchronous Model, Epoll, IO Multiplexing, and JNI with Hands‑On C Code

This article explains Netty’s asynchronous architecture, compares classic multithread, Reactor, select, poll and epoll models, clarifies level‑triggered versus edge‑triggered event handling, and provides step‑by‑step JNI and hand‑written epoll server examples in C to illustrate high‑performance backend development.

C++IO MultiplexingJNI
0 likes · 33 min read
Deep Dive into Netty’s Asynchronous Model, Epoll, IO Multiplexing, and JNI with Hands‑On C Code
Java Architect Essentials
Java Architect Essentials
Nov 7, 2024 · Backend Development

Building a Netty + WebSocket Message Push Server in Java

This tutorial explains how to use Netty to create a Java backend server with WebSocket support, covering server initialization, channel configuration, pipeline setup, custom handlers, and message‑push services, and includes complete code examples for each component.

Message PushNettyServer
0 likes · 10 min read
Building a Netty + WebSocket Message Push Server in Java
Bin's Tech Cabin
Bin's Tech Cabin
Nov 7, 2024 · Backend Development

How Netty Detects Memory Leaks: Deep Dive into LeakAwareBuffer and ResourceLeakDetector

This article provides a comprehensive analysis of Netty's memory‑leak detection mechanism, covering the design principles, leak‑aware buffers, reference handling, sampling strategies, detection levels, and the internal models that enable accurate identification of unreleased native memory in both pooled and unpooled ByteBuf allocations.

Memory Leak DetectionNettyResourceLeakDetector
0 likes · 44 min read
How Netty Detects Memory Leaks: Deep Dive into LeakAwareBuffer and ResourceLeakDetector
JavaEdge
JavaEdge
Aug 31, 2024 · Backend Development

How I Traced and Fixed a Netty Off‑Heap Memory Leak in a WebSocket Service

This article details a step‑by‑step investigation of a Netty off‑heap memory leak that caused Nginx 5xx errors, covering background, alert analysis, multiple debugging stages, reflective monitoring, the root‑cause NPE fix, and verification in both local and production environments.

DebuggingNettyOff-heap memory
0 likes · 14 min read
How I Traced and Fixed a Netty Off‑Heap Memory Leak in a WebSocket Service
Bin's Tech Cabin
Bin's Tech Cabin
Aug 20, 2024 · Backend Development

How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety

This article examines Netty 4.1.x’s ByteBuf reference‑counting mechanism, explains why reference counting was introduced, traces its original design, shows instruction‑level optimizations, reveals concurrency bugs in version 4.1.17, and details the clever even‑odd redesign that guarantees thread‑safe memory release while preserving high performance.

ByteBufNettyconcurrency
0 likes · 34 min read
How Netty’s ByteBuf Reference Counting Evolved: From Simple Counters to Parity‑Based Concurrency Safety
JD Tech
JD Tech
Aug 1, 2024 · Backend Development

Overview of RPC and How to Build a Custom RPC Framework Using Netty

This article explains the fundamentals and key characteristics of Remote Procedure Call (RPC), outlines common use cases and popular frameworks, and then walks through the design and implementation of a simple custom RPC system—including a bespoke binary protocol, client‑side proxy generation, serialization, Netty‑based encoding/decoding, server‑side request handling, and result delivery—using Java and Netty.

NettyRPCbackend development
0 likes · 21 min read
Overview of RPC and How to Build a Custom RPC Framework Using Netty
JD Cloud Developers
JD Cloud Developers
Jul 22, 2024 · Backend Development

Building a Custom RPC Framework with Netty: A Step‑by‑Step Guide

This article introduces the fundamentals and key features of Remote Procedure Call (RPC), explores common use cases and popular frameworks, then walks through the design and implementation of a custom RPC system using Netty, covering protocol design, client‑server communication, serialization, encoding, decoding, and result handling.

NettyRPCcustom protocol
0 likes · 23 min read
Building a Custom RPC Framework with Netty: A Step‑by‑Step Guide
High Availability Architecture
High Availability Architecture
Jul 11, 2024 · Backend Development

AutoMQ Memory Cache Design and Mitigating Netty PooledByteBufAllocator Memory Fragmentation

The article explains AutoMQ's memory‑cache architecture, compares LogCache and BlockCache designs, analyzes Netty's internal and external memory fragmentation caused by the Buddy and PageRun/PoolSubpage allocators, and presents mitigation techniques such as ByteBufSeqAlloc to reduce OOM risks.

CacheDesignDirectMemoryMemoryFragmentation
0 likes · 14 min read
AutoMQ Memory Cache Design and Mitigating Netty PooledByteBufAllocator Memory Fragmentation
Cognitive Technology Team
Cognitive Technology Team
Jul 7, 2024 · Backend Development

Understanding TCP Packet Framing Issues and Netty Decoder Solutions

This article explains the TCP packet fragmentation and aggregation problems, introduces Netty's various decoder mechanisms such as FixedLengthFrameDecoder, LineBasedFrameDecoder, DelimiterBasedFrameDecoder, LengthFieldPrepender, and LengthFieldBasedFrameDecoder, and provides detailed configuration examples and code snippets for implementing robust TCP protocols.

FramingNettyTCP
0 likes · 7 min read
Understanding TCP Packet Framing Issues and Netty Decoder Solutions
Selected Java Interview Questions
Selected Java Interview Questions
May 19, 2024 · Backend Development

Netty Interview Questions and Answers: Core Concepts and Features

This article provides a comprehensive set of Netty interview questions and detailed answers covering its architecture, Reactor pattern, core components such as Channel, ChannelHandler, ChannelPipeline, ByteBuf advantages, EventLoop groups, codecs, handling of packet framing, and graceful shutdown procedures.

Nettyasynchronous IObackend
0 likes · 10 min read
Netty Interview Questions and Answers: Core Concepts and Features
Top Architect
Top Architect
May 15, 2024 · Backend Development

Implementing a Simple Java RPC Framework: Architecture, Service Registration, Serialization, and Proxy Generation

This article explains the principles and implementation of a Java RPC framework, covering service registration with Zookeeper, serialization, compression, network communication via Netty, dynamic proxy generation using reflection and Javassist, and performance considerations, providing extensive code examples for each component.

JavassistNettyRPC
0 likes · 25 min read
Implementing a Simple Java RPC Framework: Architecture, Service Registration, Serialization, and Proxy Generation
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 11, 2024 · Backend Development

Netty Packet Framing: Handling TCP Sticky and Unsticky Packets

This article explains TCP packet fragmentation and aggregation (sticky/unsticky packets), demonstrates the phenomena with examples, and provides detailed solutions using Netty's built‑in decoders such as FixedLengthFrameDecoder, LineBasedFrameDecoder, DelimiterBasedFrameDecoder, and LengthFieldBasedFrameDecoder, including code samples and configuration tips.

NettyTCPdecoder
0 likes · 26 min read
Netty Packet Framing: Handling TCP Sticky and Unsticky Packets
Top Architect
Top Architect
Apr 26, 2024 · Backend Development

Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing

This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.

NettyRedisSpring Boot
0 likes · 22 min read
Netty TCP Client Demo: Architecture Overview, Code Walkthrough, and Testing
High Availability Architecture
High Availability Architecture
Apr 22, 2024 · Backend Development

Debugging Redis Lettuce Timeout Issues in a Spring Cloud Backend

An in‑depth investigation of a Redis timeout problem in a Spring Cloud backend reveals that the Lettuce client’s Netty EventLoop threads become blocked by synchronous Pub/Sub callbacks, causing socket buffer buildup, and proposes solutions such as increasing I/O threads or off‑loading processing to avoid the issue.

NettyRedisSpring Cloud
0 likes · 15 min read
Debugging Redis Lettuce Timeout Issues in a Spring Cloud Backend
iQIYI Technical Product Team
iQIYI Technical Product Team
Apr 19, 2024 · Databases

Root Cause Analysis of Redis Timeout in a Spring Cloud Service Using Lettuce and Netty

A Docker image upgrade reduced Netty EventLoop threads, causing a Pub/Sub listener’s blocking Future.get() to stall one thread, fill a Redis cluster connection’s receive buffer and trigger widespread Redis timeouts in the custom Lettuce cache framework, which were eliminated by increasing I/O threads or making the callback asynchronous.

DebuggingDockerEventLoop
0 likes · 15 min read
Root Cause Analysis of Redis Timeout in a Spring Cloud Service Using Lettuce and Netty
High Availability Architecture
High Availability Architecture
Apr 11, 2024 · Backend Development

Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components

This article provides a comprehensive overview of Netty's core layers, protocol support, transport services, logical architecture, various I/O models, packet framing techniques, custom protocol design, write‑and‑flush behavior, off‑heap memory management, and high‑performance data structures such as FastThreadLocal and HashedTimerWheel.

Memory ManagementNettyhigh performance
0 likes · 26 min read
Understanding Netty's Core Architecture, I/O Models, Memory Management, and High‑Performance Components
DaTaobao Tech
DaTaobao Tech
Apr 8, 2024 · Backend Development

Netty Core Concepts and Architecture Overview

Netty is a high‑performance network framework whose three‑layer architecture—Core, Protocol Support, and Transport Service—combined with a Reactor‑based logical design, diverse I/O models, advanced memory management, zero‑copy techniques, and optimized data structures, enables efficient custom protocol handling and scalable server development.

I/O ModelsNettyReactor pattern
0 likes · 27 min read
Netty Core Concepts and Architecture Overview
Mike Chen's Internet Architecture
Mike Chen's Internet Architecture
Apr 3, 2024 · Backend Development

Comprehensive Introduction to Netty: Features, Architecture, Core Components, and Application Scenarios

This article provides a detailed overview of Netty, a high‑performance asynchronous NIO framework, covering its key features, architectural design, core components, high‑performance strategies, and typical use cases in internet services, gaming, and big‑data systems, while also highlighting why it outperforms native JDK NIO.

Java NIONettyNetwork Framework
0 likes · 9 min read
Comprehensive Introduction to Netty: Features, Architecture, Core Components, and Application Scenarios
Su San Talks Tech
Su San Talks Tech
Mar 12, 2024 · Backend Development

Why Is RocketMQ So Fast? 10 Core Techniques Explained

This article explores the ten key architectural and implementation techniques—such as batch messaging, compression, Netty networking, zero‑copy I/O, sequential writes, efficient storage structures, asynchronous processing, batch handling, lock optimizations, and thread‑pool isolation—that together make RocketMQ a high‑performance message middleware.

NettyRocketMQjava
0 likes · 21 min read
Why Is RocketMQ So Fast? 10 Core Techniques Explained
Sanyou's Java Diary
Sanyou's Java Diary
Mar 11, 2024 · Backend Development

Why RocketMQ Is So Fast: 10 Core Performance Techniques Explained

This article breaks down the ten key mechanisms—batch sending, message compression, Netty‑based networking, zero‑copy I/O, sequential writes, optimized storage structures, asynchronous flushing and replication, batch processing, lock refinements, and thread‑pool isolation—that together give RocketMQ its remarkable speed and efficiency.

Message QueueNettyRocketMQ
0 likes · 20 min read
Why RocketMQ Is So Fast: 10 Core Performance Techniques Explained
Java Architect Essentials
Java Architect Essentials
Feb 29, 2024 · Backend Development

Building a Real‑Time Chat System with Netty, SpringBoot, and JavaFX

This article walks through the design and implementation of a three‑tier instant‑messaging platform—including a Netty‑based chat server, a JavaFX client, and a SpringBoot web admin console—covering architecture, protocol design, database schema, key Netty handlers, threading, and authentication details.

Database DesignInstant MessagingJavaFX
0 likes · 30 min read
Building a Real‑Time Chat System with Netty, SpringBoot, and JavaFX
Code Ape Tech Column
Code Ape Tech Column
Feb 17, 2024 · Backend Development

Understanding Netty’s Asynchronous Model, Epoll, and IO Multiplexing: Theory, JNI Integration, and a Hand‑Written Epoll Server

This article explains Netty’s reactor‑based asynchronous architecture, compares classic multithread, select, poll and epoll I/O multiplexing models, demonstrates Java‑C interaction via JNI, and provides a complete hand‑written epoll server implementation with detailed code and performance insights.

C++IO MultiplexingJNI
0 likes · 36 min read
Understanding Netty’s Asynchronous Model, Epoll, and IO Multiplexing: Theory, JNI Integration, and a Hand‑Written Epoll Server
Architect
Architect
Jan 10, 2024 · Backend Development

Design and Performance Optimization of a Custom API Gateway (DAG)

This article presents a comprehensive analysis of the limitations of Spring Cloud Gateway, proposes a self‑developed API gateway architecture called DAG, details its core components such as request context, filter chain, async client, routing, and connection management, and demonstrates through extensive performance testing that DAG achieves significantly higher throughput, lower latency, and improved stability compared to the original SCG solution.

API GatewayNettyReactive Programming
0 likes · 39 min read
Design and Performance Optimization of a Custom API Gateway (DAG)
LouZai
LouZai
Dec 14, 2023 · Backend Development

How Ctrip Handles 20 Billion Daily Requests: Inside Its High‑Performance API Gateway

Facing 20 billion daily requests, Ctrip’s API gateway evolved from a Zuul‑based prototype to a fully asynchronous, single‑threaded Netty design, employing RxJava, custom flow control, multi‑protocol support, and modular governance to achieve high throughput, low latency, and scalable operations.

API GatewayAsynchronous DesignMicroservices
0 likes · 20 min read
How Ctrip Handles 20 Billion Daily Requests: Inside Its High‑Performance API Gateway
DaTaobao Tech
DaTaobao Tech
Dec 8, 2023 · Backend Development

ZSTD Compression and GC Optimization in Java Netty Backend

Switching a Java Netty gateway from GZIP to ZSTD compression using zstd‑jni doubled GC time and introduced heap and Netty off‑heap memory leaks, which were resolved by employing the library’s direct off‑heap API with a NoFinalizer compressor, promptly releasing ByteBufs, avoiding finalize(), and adopting jemalloc to reduce fragmentation.

GCMemoryLeakNetty
0 likes · 19 min read
ZSTD Compression and GC Optimization in Java Netty Backend
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Dec 7, 2023 · Backend Development

In-Depth Analysis of XXL‑RPC Framework: Design, Implementation, and Source Code Walkthrough

This article provides a comprehensive overview of the lightweight XXL‑RPC framework, covering fundamental RPC concepts, the framework's architecture built on Spring and Netty, detailed provider and consumer implementations, various call types, and the service registry‑discovery mechanism, concluding with practical insights for developers.

MicroservicesNettyRPC
0 likes · 17 min read
In-Depth Analysis of XXL‑RPC Framework: Design, Implementation, and Source Code Walkthrough
Sohu Tech Products
Sohu Tech Products
Oct 25, 2023 · Backend Development

Deep Analysis of Netty FastThreadLocal: From Production Issue to Source Code Implementation

The article traces a production bug where unreleased JDK ThreadLocal data corrupted user info, then compares JDK ThreadLocal with Netty’s FastThreadLocal, detailing their source‑code implementations, performance trade‑offs (O(n) vs O(1) access), memory‑leak risks, and recommends explicit remove() calls to avoid leaks.

FastThreadLocalMemory ManagementNetty
0 likes · 15 min read
Deep Analysis of Netty FastThreadLocal: From Production Issue to Source Code Implementation
vivo Internet Technology
vivo Internet Technology
Oct 18, 2023 · Backend Development

Understanding JDK ThreadLocal and Netty FastThreadLocal: Implementation, Advantages, and Best Practices

The article compares JDK ThreadLocal and Netty FastThreadLocal, detailing their implementations, performance trade‑offs, and memory‑leak risks, illustrates a real‑world HTTPS bug caused by missing remove() calls, and recommends always cleaning up ThreadLocal values while noting FastThreadLocal’s O(1) access may not always outperform the JDK version.

FastThreadLocalMemoryLeakNetty
0 likes · 17 min read
Understanding JDK ThreadLocal and Netty FastThreadLocal: Implementation, Advantages, and Best Practices
Top Architect
Top Architect
Oct 11, 2023 · Backend Development

Netty TCP Client Demo with Spring Boot: Architecture, Implementation, and Testing

This article presents a complete Netty TCP client demo built with Spring Boot, detailing the project architecture, module layout, business flow, key code implementations—including a local BlockingQueue, message processing with Redis locks, client initialization, handler logic, and testing endpoints—providing a practical reference for backend developers.

Message QueueNettySpring Boot
0 likes · 21 min read
Netty TCP Client Demo with Spring Boot: Architecture, Implementation, and Testing
Java Architecture Diary
Java Architecture Diary
Oct 10, 2023 · Backend Development

Running Spring Cloud Gateway on Traditional Servlet Containers: MVC Support Explained

This article explains why Spring Cloud Gateway originally required Netty and could not run in traditional Servlet containers, introduces the new MVC Servlet support added in Spring Cloud 2023 (Gateway 4.1), and provides step‑by‑step instructions for configuring dependencies, routing rules, and custom filters using Tomcat or other servlet containers.

MVCNettyServlet
0 likes · 6 min read
Running Spring Cloud Gateway on Traditional Servlet Containers: MVC Support Explained