BestHub
Sign in
Tagged articles
333 articles
Page 3 of 4
Ctrip Technology
Ctrip Technology
Sep 23, 2021 · Backend Development

Design and Implementation of Ctrip's High‑Performance API Gateway

This article presents the evolution, architecture, and engineering practices of Ctrip's API gateway, covering its transition to full asynchronous processing with Netty and RxJava, stream‑based forwarding, single‑threaded event‑loop design, performance optimizations, multi‑protocol support, routing, and modular governance for large‑scale microservice environments.

Async ArchitectureNettyRxJava
0 likes · 17 min read
Design and Implementation of Ctrip's High‑Performance API Gateway
IT Architects Alliance
IT Architects Alliance
Sep 22, 2021 · Operations

Resource Isolation Strategies in Distributed Systems

The article explains why resource isolation is essential for distributed architectures, describes common isolation methods such as thread, process, cluster, data, static and crawler isolation, and provides concrete examples and code snippets for Netty, Dubbo, Tomcat, and Hystrix to illustrate practical implementations.

Distributed SystemsDubboNetty
0 likes · 12 min read
Resource Isolation Strategies in Distributed Systems
vivo Internet Technology
vivo Internet Technology
Sep 22, 2021 · Backend Development

Investigation and Resolution of Netty ChannelOutboundBuffer Memory Leak in a Mobile Push System

In a high‑throughput mobile push service built on Netty, an off‑heap memory leak was traced to unchecked ChannelOutboundBuffer growth when half‑closed connections remained active but unwritable; fixing it by disabling autoRead on unwritable channels, configuring write‑buffer watermarks, and adding explicit isWritable() checks eliminated the crash and stabilized the system.

ChannelOutboundBufferNettyjava
0 likes · 10 min read
Investigation and Resolution of Netty ChannelOutboundBuffer Memory Leak in a Mobile Push System
Programmer DD
Programmer DD
Sep 21, 2021 · Backend Development

Why Adding More Dubbo Connections Doesn’t Always Boost Throughput

This article examines Dubbo’s connection‑control feature, demonstrates how long‑living TCP connections are created, runs benchmark tests with one and two connections, discovers that varying IO thread counts skew results, and shows that increasing connections alone rarely improves throughput.

Connection ControlDubboIO Threads
0 likes · 14 min read
Why Adding More Dubbo Connections Doesn’t Always Boost Throughput
Top Architect
Top Architect
Sep 18, 2021 · Backend Development

Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More

The article explains why resource isolation is essential in distributed architectures and details various isolation strategies—including thread, process, cluster, data read/write, static, and crawler isolation—illustrated with Netty, Dubbo, Tomcat examples, code snippets, and a comparison of thread‑pool versus semaphore isolation in Hystrix.

Distributed SystemsDubboHystrix
0 likes · 13 min read
Resource Isolation Techniques in Distributed Systems: Thread, Process, Cluster, and More
Open Source Linux
Open Source Linux
Sep 8, 2021 · Backend Development

Build Real‑Time Messaging with the Open‑Source CIM Framework – A Hands‑On Overview

This article introduces the open‑source CIM instant‑messaging system, explains its Netty/WebSocket‑based backend architecture, outlines the available client SDKs and server modules, and showcases functional previews for console, Android, and web clients, guiding developers on how to adopt or adapt the solution.

CIMInstant MessagingNetty
0 likes · 4 min read
Build Real‑Time Messaging with the Open‑Source CIM Framework – A Hands‑On Overview
IT Architects Alliance
IT Architects Alliance
Sep 7, 2021 · Backend Development

Implementing Delayed Tasks: Strategies, Code Samples, and Trade‑offs

This article explains various approaches to implementing delayed tasks in backend systems, comparing database polling, Java's DelayQueue, Netty's time wheel, Redis sorted sets and keyspace notifications, and RabbitMQ delayed queues, with detailed code examples and analysis of each method's pros and cons.

NettyRabbitMQScheduling
0 likes · 17 min read
Implementing Delayed Tasks: Strategies, Code Samples, and Trade‑offs
IT Architects Alliance
IT Architects Alliance
Aug 19, 2021 · Backend Development

Deep Dive into RocketMQ Architecture, Principles, and Source Code

This article provides a comprehensive overview of RocketMQ's evolution, core architecture, communication flow, storage mechanisms, flushing strategies, high‑availability synchronization, and transaction message implementation, illustrating each component with diagrams and key source‑code excerpts for developers seeking an in‑depth understanding of the system.

Message QueueNettyRocketMQ
0 likes · 13 min read
Deep Dive into RocketMQ Architecture, Principles, and Source Code
HelloTech
HelloTech
Aug 11, 2021 · Backend Development

Root Cause Analysis and Optimization of Long Young GC Times in gRPC/Netty Services

Long Young GC pauses in gRPC/Netty services were traced to Netty’s default thread‑local cache creating many MpscArrayQueue objects, and disabling the cache with the JVM options ‑Dio.netty.allocator.useCacheForAllThreads=false and ‑Dio.grpc.netty.shaded.io.netty.allocator.useCacheForAllThreads=false reduced GC time from up to 900 ms to about 100 ms, stabilizing the service.

GC optimizationNettyThread Cache
0 likes · 6 min read
Root Cause Analysis and Optimization of Long Young GC Times in gRPC/Netty Services
Java Interview Crash Guide
Java Interview Crash Guide
Jul 19, 2021 · Backend Development

Mastering Zero-Copy in Java: Boost Performance with NIO, Netty, and More

Zero-copy techniques eliminate unnecessary data copying between user and kernel space, dramatically improving I/O performance; this article explains core I/O concepts, explores Java implementations like MappedByteBuffer, DirectByteBuffer, channel-to-channel transfers, and demonstrates Netty’s composite buffers, plus examples from Kafka and RocketMQ.

Memory Mapped FilesNettyZero Copy
0 likes · 14 min read
Mastering Zero-Copy in Java: Boost Performance with NIO, Netty, and More
Yang Money Pot Technology Team
Yang Money Pot Technology Team
Jul 15, 2021 · Backend Development

Spring Cloud Gateway: Principles and Practical Applications

This article explains the architecture, core concepts, routing mechanisms, configuration options, and extensibility of Spring Cloud Gateway, illustrating how it replaces Zuul with a non‑blocking Netty‑based solution and how to customize routes, predicates, filters, and dynamic updates for microservice environments.

FiltersNettySpring Cloud Gateway
0 likes · 27 min read
Spring Cloud Gateway: Principles and Practical Applications
Alibaba Cloud Developer
Alibaba Cloud Developer
Jul 9, 2021 · Backend Development

How to Build Your Own Distributed RPC Framework from Scratch

This article walks through the motivation, core components, technology choices, architecture, and implementation details—including service registration, provider and consumer modules, custom protocol design, serialization, load balancing, and Netty-based I/O—of a self‑written distributed RPC framework, and presents performance test results.

Distributed SystemsNettyRPC
0 likes · 17 min read
How to Build Your Own Distributed RPC Framework from Scratch
Alibaba Cloud Developer
Alibaba Cloud Developer
Jun 22, 2021 · Backend Development

Why Netty? Building High‑Performance Distributed Services with Java

This article explains what Netty is, how to design a distributed service framework using it, details the RPC call flow, discusses protocol design, showcases performance‑boosting features and best practices, and provides deep insights into Netty's architecture, threading model, and low‑level optimizations.

Distributed SystemsNettyRPC
0 likes · 19 min read
Why Netty? Building High‑Performance Distributed Services with Java
Top Architect
Top Architect
Jun 21, 2021 · Backend Development

Implementing High‑Performance Long‑Connection Services with Netty: Challenges and Optimizations

This article explains how to build a scalable long‑connection service using Netty, covering the underlying concepts, Linux kernel tuning, code examples for Java NIO and Netty, performance bottlenecks such as QPS, data‑structure and GC issues, and practical optimization techniques to achieve hundreds of thousands of concurrent connections.

Java NIOLinux TuningNetty
0 likes · 13 min read
Implementing High‑Performance Long‑Connection Services with Netty: Challenges and Optimizations
ITPUB
ITPUB
May 10, 2021 · Backend Development

Unveiling RocketMQ NameServer: How Seven Classes Power the Registry

This article breaks down the design and source‑code implementation of RocketMQ's NameServer, detailing its core responsibilities, component interactions, and the seven Java classes that together provide network handling, connection management, routing, configuration, and startup logic.

Backend ArchitectureDistributed SystemsMessage Queue
0 likes · 11 min read
Unveiling RocketMQ NameServer: How Seven Classes Power the Registry
Alibaba Cloud Native
Alibaba Cloud Native
May 3, 2021 · Backend Development

Why Dubbo Fails Under C10K Load and How to Fix It

This article details a large‑scale C10K performance test of Dubbo, analyzes why service calls time out under thousands of concurrent consumers, identifies heartbeat‑induced Netty thread saturation and TCP full‑connection‑queue overflow as root causes, and presents concrete optimizations that dramatically improve latency and stability.

Backend PerformanceC10KDubbo
0 likes · 13 min read
Why Dubbo Fails Under C10K Load and How to Fix It
21CTO
21CTO
Apr 30, 2021 · Backend Development

Why Dubbo Times Out Under C10K Load and How to Fix It

This article analyzes the C10K scenario where Dubbo‑based services experience massive timeout failures, examines root causes such as heartbeat‑induced Netty thread saturation and TCP backlog overflow, and presents a series of optimizations that dramatically improve latency, CPU usage, and stability in large‑scale deployments.

C10KDubboNetty
0 likes · 14 min read
Why Dubbo Times Out Under C10K Load and How to Fix It
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 30, 2021 · Backend Development

Why Netty Is the Go-To Framework for High‑Performance Java Backend Development

This article explains how Netty, an asynchronous event‑driven Java NIO framework, simplifies building high‑performance, maintainable network servers and clients by handling I/O, threading, and protocol concerns, and it covers its thread models, zero‑copy techniques, common interview questions, and real‑world use cases such as Dubbo and RocketMQ.

AsynchronousNettyZero Copy
0 likes · 36 min read
Why Netty Is the Go-To Framework for High‑Performance Java Backend Development
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 29, 2021 · Backend Development

Why Netty Is the Go-To Framework for High‑Performance Java Backend Development

This article explains how Netty, an asynchronous event‑driven network framework built on Java NIO, simplifies the creation of high‑performance, scalable web servers and client components by handling I/O streams, connection management, threading, zero‑copy transfers, and offering flexible reactor thread models for various application scenarios.

NettyNetwork programmingReactor Model
0 likes · 39 min read
Why Netty Is the Go-To Framework for High‑Performance Java Backend Development
IT Xianyu
IT Xianyu
Mar 31, 2021 · Backend Development

Open-Source Instant Messaging System (CIM) Overview and Features

This article introduces the open‑source CIM instant messaging system, detailing its server‑side architecture based on Netty or Mina, multi‑platform client support (WebSocket, Android, iOS, desktop), core modules, directory structure, and a preview of its console and client interfaces.

CIMInstant MessagingMobile
0 likes · 4 min read
Open-Source Instant Messaging System (CIM) Overview and Features
High Availability Architecture
High Availability Architecture
Mar 29, 2021 · Backend Development

Design and Implementation of a WebSocket Long‑Connection Gateway for Real‑Time Push

This article presents the design, implementation, and performance evaluation of a Netty‑based WebSocket long‑connection gateway that centralizes session management, decouples business logic, supports horizontal scaling, and provides monitoring and alerting for high‑throughput real‑time data push in iQIYI’s platform.

NettyRocketMQWebSocket
0 likes · 12 min read
Design and Implementation of a WebSocket Long‑Connection Gateway for Real‑Time Push
Programmer DD
Programmer DD
Mar 16, 2021 · Backend Development

Understanding Netty’s Thread Model: Reactor Patterns and Performance Optimizations

This article explains Netty’s high‑performance asynchronous NIO architecture, introduces the Reactor pattern and its three thread‑model variants, and details Netty’s core components such as Selector, EventLoopGroup, ChannelPipeline, and ByteBuf, highlighting how they improve scalability and efficiency.

Java NIONettyReactor Pattern
0 likes · 11 min read
Understanding Netty’s Thread Model: Reactor Patterns and Performance Optimizations
IT Architects Alliance
IT Architects Alliance
Mar 14, 2021 · Backend Development

Evolution and Performance Optimization of Ximalaya’s HTTP Gateway: From Tomcat NIO to Netty Full‑Async Architecture

This article describes how Ximalaya’s high‑traffic HTTP gateway evolved from a Tomcat NIO + AsyncServlet design to a Netty‑based fully asynchronous architecture, detailing the challenges of blocking I/O, memory copying, GC pressure, and how layered redesign, lock‑free connection pools, comprehensive monitoring, and performance optimizations enabled stable handling of over 200 billion daily calls with peak QPS exceeding 40 k per machine.

AsynchronousNettygateway
0 likes · 15 min read
Evolution and Performance Optimization of Ximalaya’s HTTP Gateway: From Tomcat NIO to Netty Full‑Async Architecture
21CTO
21CTO
Mar 1, 2021 · Backend Development

How to Build a Scalable WebSocket Long‑Connection Gateway with Netty

This article explains the challenges of server‑push in HTTP, reviews WebSocket as the mainstream solution, and details the design, implementation, session management, monitoring, and performance testing of a Netty‑based distributed WebSocket long‑connection gateway used at iQIYI.

NettyWebSocketdistributed architecture
0 likes · 12 min read
How to Build a Scalable WebSocket Long‑Connection Gateway with Netty
iQIYI Technical Product Team
iQIYI Technical Product Team
Feb 26, 2021 · Backend Development

Design and Implementation of a WebSocket Long‑Connection Gateway for iQIYI Services

iQIYI built a Netty‑based WebSocket long‑connection gateway that centralizes session management, uses RocketMQ for cluster‑wide broadcast, provides a simple HTTP push API, scales horizontally to millions of connections, integrates Prometheus/Grafana monitoring, and dramatically cuts development effort for real‑time features such as comments and authentication.

NettyPerformance TestingRocketMQ
0 likes · 15 min read
Design and Implementation of a WebSocket Long‑Connection Gateway for iQIYI Services
Code Ape Tech Column
Code Ape Tech Column
Feb 24, 2021 · Backend Development

How to Build a High‑Performance Java RPC Framework with Netty, Zookeeper, and Custom Load Balancing

This article walks through the design and implementation of a Java RPC framework, detailing added serialization options, multiple load‑balancing strategies, client‑side service caching, TCP long‑connection handling with Netty, performance testing, and provides the full source code for replication.

NettyPerformance TestingRPC
0 likes · 17 min read
How to Build a High‑Performance Java RPC Framework with Netty, Zookeeper, and Custom Load Balancing
Architect's Tech Stack
Architect's Tech Stack
Feb 15, 2021 · Backend Development

Enhancing a Java RPC Framework: Protobuf/Kryo Serialization, Load‑Balancing Strategies, Connection Pooling and Performance Gains

This article describes a series of improvements to a Spring‑Boot based Java RPC framework—including support for Protobuf and Kryo serialization, multiple load‑balancing algorithms, client‑side service caching, TCP long‑connection reuse via Netty, and a performance test that reduces request latency by more than tenfold.

NettyRPCSpring Boot
0 likes · 15 min read
Enhancing a Java RPC Framework: Protobuf/Kryo Serialization, Load‑Balancing Strategies, Connection Pooling and Performance Gains
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Feb 5, 2021 · Backend Development

Scaling Netty RPC with Protostuff: 400k Objects/sec per Server

An in‑depth guide demonstrates how to combine Netty with Protostuff for high‑performance RPC, detailing serialization setup, custom encoder/decoder implementation, multi‑threading pitfalls, and stress‑testing results that achieve up to 400,000 objects per second per server in a clustered environment.

NettyProtostuffRPC
0 likes · 11 min read
Scaling Netty RPC with Protostuff: 400k Objects/sec per Server
Code Ape Tech Column
Code Ape Tech Column
Feb 2, 2021 · Backend Development

Implementing Heartbeat and Reconnection Mechanisms with Netty in Java

This article explains the concept of TCP heartbeat, demonstrates how to use Netty's IdleStateHandler to implement client‑server heartbeat detection, and provides a complete Java example with reconnection logic, retry policies, and detailed code snippets for building a robust long‑connection service.

HeartbeatNettyTCP
0 likes · 18 min read
Implementing Heartbeat and Reconnection Mechanisms with Netty in Java
21CTO
21CTO
Jan 29, 2021 · Backend Development

Scaling Netty RPC with Protostuff: High‑Throughput Serialization Tips

This article details how to build a high‑performance Netty RPC system using Protostuff for serialization, covering dependency setup, custom encoder/decoder implementation, multithreaded buffer handling, and stress‑test results that achieve hundreds of thousands of objects per second per server.

NettyProtostuffRPC
0 likes · 10 min read
Scaling Netty RPC with Protostuff: High‑Throughput Serialization Tips
Sohu Tech Products
Sohu Tech Products
Jan 28, 2021 · Operations

Performance Troubleshooting: JVM Safepoint, Biased Locking, Netty Worker Blocking, and Log Framework Issues

This article details a systematic investigation of various backend performance problems—including CMS GC delays, biased‑lock revocation, Netty worker thread blocking, and log‑framework overhead—provides root‑cause analysis, JVM tuning parameters, and practical recommendations to mitigate latency spikes in production services.

BackendJVMNetty
0 likes · 16 min read
Performance Troubleshooting: JVM Safepoint, Biased Locking, Netty Worker Blocking, and Log Framework Issues
JD Retail Technology
JD Retail Technology
Dec 28, 2020 · Backend Development

Simplified Analysis of Netty Server and Client Startup and Communication

This article provides a concise, code‑driven walkthrough of Netty's core components—including event‑loop groups, channel initialization, pipeline handling, and the server‑client handshake process—by simplifying the original source to highlight the essential mechanisms behind asynchronous network communication in Java.

Channel pipelineJava NIONetty
0 likes · 19 min read
Simplified Analysis of Netty Server and Client Startup and Communication
JavaEdge
JavaEdge
Dec 25, 2020 · Backend Development

How Netty Accepts Connections: Inside NioEventLoop and Worker Threads

This article explains how Netty's boss and worker NioEventLoop threads collaborate to accept socket connections, register selectors, and transition to read operations, detailing the underlying selector polling, OP_ACCEPT handling, and the code paths that trigger channel activation.

BackendJava NIONetty
0 likes · 4 min read
How Netty Accepts Connections: Inside NioEventLoop and Worker Threads
JavaEdge
JavaEdge
Dec 22, 2020 · Backend Development

Demystifying Netty's Main, Boss, and Worker Threads in Java NIO

This article explains how Netty creates and uses the main thread, boss thread, and worker threads through NioEventLoopGroup and selectors, detailing the initialization of ServerSocketChannel, event registration, and the transition from OP_ACCEPT registration to active listening.

BackendNettyNioEventLoopGroup
0 likes · 3 min read
Demystifying Netty's Main, Boss, and Worker Threads in Java NIO
JavaEdge
JavaEdge
Dec 15, 2020 · Backend Development

Mastering Netty Codecs: From ByteToMessageDecoder to Fixed‑Length and Line Decoders

This guide explains how Netty handles encoding and decoding, covering abstract decoder classes, concrete implementations like ByteToMessageDecoder, ReplayingDecoder, fixed‑length and line‑based decoders, and essential reference‑count management for building robust network applications.

ByteToMessageDecoderDecoderNetty
0 likes · 6 min read
Mastering Netty Codecs: From ByteToMessageDecoder to Fixed‑Length and Line Decoders
vivo Internet Technology
vivo Internet Technology
Dec 15, 2020 · Backend Development

Designing a High‑Performance Java‑Based API Gateway with Zuul2 and Netty

This article details the background, technology selection, Zuul2 architecture, HTTP parsing, Netty pipeline, filter chains, dynamic configuration, routing, load balancing, security, monitoring, zero‑downtime deployment, cluster isolation, and migration strategies for building a robust Java‑centric API gateway.

Dynamic ConfigurationMicroservicesNetty
0 likes · 23 min read
Designing a High‑Performance Java‑Based API Gateway with Zuul2 and Netty
JavaEdge
JavaEdge
Dec 12, 2020 · Backend Development

Why Does TCP Have Sticky and Half Packets? Causes and Effective Solutions

This article explains why TCP experiences sticky and half packets, analyzes the underlying causes such as buffer size mismatches and MTU limits, and presents practical solutions including short connections, fixed‑length framing, delimiter‑based framing, and length‑field framing, with their advantages and trade‑offs.

NettyNetwork programmingTCP
0 likes · 5 min read
Why Does TCP Have Sticky and Half Packets? Causes and Effective Solutions
Programmer DD
Programmer DD
Dec 1, 2020 · Backend Development

Mastering Zero-Copy in Java: Boost I/O Performance with NIO, Netty & Kafka

Zero-copy techniques eliminate unnecessary data copying between user and kernel space, dramatically improving I/O performance; this article explains core concepts, Java NIO’s MappedByteBuffer and DirectByteBuffer, channel-to-channel transfers, Netty’s composite buffers, and how frameworks like Kafka and RocketMQ leverage zero-copy.

NettyZero Copyjava
0 likes · 12 min read
Mastering Zero-Copy in Java: Boost I/O Performance with NIO, Netty & Kafka
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Nov 30, 2020 · Backend Development

Netty Architecture and Principles: An Introductory Tutorial

This tutorial provides a detailed introduction to Netty, covering its architecture, core concepts such as buffers, channels, selectors, reactor thread models, zero‑copy techniques, and includes practical TCP server/client code examples, helping readers understand and apply Netty for high‑performance Java network programming.

Java NIONettyReactor
0 likes · 42 min read
Netty Architecture and Principles: An Introductory Tutorial
Qunar Tech Salon
Qunar Tech Salon
Nov 25, 2020 · Backend Development

Diagnosing and Resolving Thread Leak in a Java Backend System

This article describes how the author investigated recurring errors in a Java-based lecture hall system, identified thread pool leaks caused by improper use of AsyncHttpClient, and resolved the issue through command‑line diagnostics, code fixes, and system monitoring, improving stability.

DubboNettyThread Leak
0 likes · 7 min read
Diagnosing and Resolving Thread Leak in a Java Backend System
Top Architect
Top Architect
Nov 17, 2020 · Backend Development

Java Netty‑Based Chat Application with Swing UI and MySQL Integration

This article details the design and implementation of a Java chat system that uses Netty for server‑side networking, Swing for the client UI, and MySQL with C3P0 for data persistence, covering features such as user authentication, friend management, single‑chat messaging, and online status detection.

NettyNetworkingSwing
0 likes · 23 min read
Java Netty‑Based Chat Application with Swing UI and MySQL Integration
Java Captain
Java Captain
Nov 14, 2020 · Backend Development

Netty‑Based Chat Application: Functional Implementation and Code Walkthrough

This article presents a comprehensive walkthrough of a Java chat application built with Netty for server‑side communication and Swing for the client UI, detailing functional features such as password, nickname, and signature updates, friend management, single‑chat messaging, online status detection, and includes full source code snippets and execution screenshots.

Friend ManagementNettySwing
0 likes · 19 min read
Netty‑Based Chat Application: Functional Implementation and Code Walkthrough
JavaEdge
JavaEdge
Nov 2, 2020 · Backend Development

Understanding Traditional Socket vs Netty: Core Components and Workflow

This article explains the fundamentals of traditional socket programming and compares it with Netty's architecture, covering server and client components, HTTP request handling steps, Netty's NioEventLoop, Channel, ByteBuf, Pipeline, and unsafe implementations, all illustrated with diagrams and code snippets.

NettyNetwork IObackend-development
0 likes · 6 min read
Understanding Traditional Socket vs Netty: Core Components and Workflow
JavaEdge
JavaEdge
Oct 30, 2020 · Backend Development

How Netty’s EventLoop Thread Model Powers High‑Performance Networking

This article explains Netty's thread model, covering the evolution from simple Thread usage to Executor‑based pools, the design of the EventLoop interface, task scheduling mechanisms, differences between Netty 3 and Netty 4, and how thread allocation and ThreadLocal affect performance and scalability.

EventLoopNettyThread Model
0 likes · 11 min read
How Netty’s EventLoop Thread Model Powers High‑Performance Networking
58 Tech
58 Tech
Oct 21, 2020 · Backend Development

Understanding Java Memory Pools: Netty’s Implementation and Underlying Theory

This article revisits memory allocation and reclamation concepts by examining Java's Netty memory pool implementation, its theoretical basis in jemalloc, and practical design choices such as arena allocation, thread‑local caches, pool chunks, sub‑pages, and multi‑threaded performance considerations.

Garbage CollectionNettyjava
0 likes · 21 min read
Understanding Java Memory Pools: Netty’s Implementation and Underlying Theory
Top Architect
Top Architect
Oct 21, 2020 · Backend Development

Design and Optimization of High‑Concurrency Push Services Using Netty

This article analyzes common questions about Netty‑based push services, presents a real‑world IoT case study, and provides detailed design guidelines—including kernel tuning, connection handling, heartbeat configuration, buffer management, memory pooling, logging pitfalls, TCP and JVM tuning—to help engineers build stable, scalable, and high‑performance million‑connection push systems.

NettyPush Servicememory
0 likes · 24 min read
Design and Optimization of High‑Concurrency Push Services Using Netty
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 29, 2020 · Backend Development

Analyzing and Fixing Netty FixedChannelPool Connection Timeout Bugs

This article investigates a recurring Netty connection‑pool timeout bug caused by missing acquire‑timeout handling, explains the internal workings of FixedChannelPool's acquire and release mechanisms, and presents a corrected implementation that configures an AcquireTimeoutAction, adjusts pool sizes, and removes premature timeout calls.

Connection PoolFixedChannelPoolNetty
0 likes · 29 min read
Analyzing and Fixing Netty FixedChannelPool Connection Timeout Bugs
The Dominant Programmer
The Dominant Programmer
Sep 20, 2020 · Backend Development

Integrating Protobuf with Netty for Java Object Transmission

This guide walks through building a Netty server and client that exchange Java objects using Protobuf serialization, covering .proto definition, code generation with protoc, pipeline configuration with Netty's Protobuf handlers, and full example implementations for both sides.

Code ExampleNettyProtobuf
0 likes · 8 min read
Integrating Protobuf with Netty for Java Object Transmission
Programmer DD
Programmer DD
Sep 9, 2020 · Backend Development

How to Integrate Spring Boot with Netty Using Protobuf for Efficient Data Transfer

This article walks through integrating Spring Boot with Netty and using Google Protobuf for binary data exchange, covering Protobuf basics, Maven setup, code generation, server and client implementations, heartbeat handling, reconnection logic, and testing results, all with complete Java examples.

Data TransferNettyProtobuf
0 likes · 20 min read
How to Integrate Spring Boot with Netty Using Protobuf for Efficient Data Transfer
Alibaba Cloud Developer
Alibaba Cloud Developer
Aug 6, 2020 · Backend Development

Mastering Java I/O: From BIO to Netty’s Reactor Model Explained

This article explains the evolution of Java I/O—from blocking BIO to non‑blocking NIO and asynchronous AIO—covers the Reactor pattern and its single‑thread, multi‑thread, and master‑slave models, and details Netty’s thread groups, channel pipeline, and async non‑blocking communication.

BackendI/ONetty
0 likes · 13 min read
Mastering Java I/O: From BIO to Netty’s Reactor Model Explained
Programmer DD
Programmer DD
Aug 4, 2020 · Backend Development

Mastering Sticky Packet and Splitting Issues in Netty RPC Applications

This article explains the root causes of sticky and split packet problems in TCP-based RPC frameworks, outlines four common mitigation strategies, and provides detailed Netty implementations—including FixedLengthFrameDecoder, LineBasedFrameDecoder, LengthFieldBasedFrameDecoder, and custom handlers—complete with runnable Java code examples.

NettyRPCpacket framing
0 likes · 21 min read
Mastering Sticky Packet and Splitting Issues in Netty RPC Applications
Architect
Architect
Jul 26, 2020 · Backend Development

Understanding Zero‑Copy in Java: I/O Concepts, mmap, Sendfile, and Netty

This article explains the zero‑copy technique in Java, covering basic I/O concepts, buffer management, mmap + write and Sendfile methods, and how frameworks like NIO, Netty, Kafka, and RocketMQ use these mechanisms to eliminate data copies and improve performance.

NettyZero Copyjava
0 likes · 11 min read
Understanding Zero‑Copy in Java: I/O Concepts, mmap, Sendfile, and Netty
Top Architect
Top Architect
Jul 24, 2020 · Backend Development

Implementing a Custom Protocol with Netty: Design, Encoding/Decoding, and Heartbeat

This article explains why a custom TCP protocol can be more efficient than HTTP, defines the protocol header and body format, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolver factories, server‑client bootstraps, and a Ping/Pong heartbeat mechanism—complete with runnable Java code and sample output.

HeartbeatMessage EncodingNetty
0 likes · 15 min read
Implementing a Custom Protocol with Netty: Design, Encoding/Decoding, and Heartbeat
Architecture Digest
Architecture Digest
Jul 19, 2020 · Backend Development

Implementing a Custom Protocol with Netty: Design, Encoding/Decoding, and Heartbeat

This article explains why a custom protocol can be more efficient than HTTP for service-to-service communication, defines a simple binary protocol with header and body, and demonstrates a complete Netty implementation—including message classes, encoders/decoders, resolvers, heartbeat handling, and client/server examples.

BackendHeartbeatMessage Encoding
0 likes · 18 min read
Implementing a Custom Protocol with Netty: Design, Encoding/Decoding, and Heartbeat
Programmer DD
Programmer DD
Jul 13, 2020 · Backend Development

Unlocking High-Performance I/O: Java Zero-Copy Techniques Explained

This article explains the principles of zero‑copy I/O, covering buffer concepts, virtual memory, mmap + write and sendfile methods, and demonstrates Java implementations using MappedByteBuffer, DirectByteBuffer, channel‑to‑channel transfers, as well as Netty’s CompositeChannelBuffer for efficient data handling.

NettyZero Copyjava
0 likes · 15 min read
Unlocking High-Performance I/O: Java Zero-Copy Techniques Explained
Selected Java Interview Questions
Selected Java Interview Questions
Jul 6, 2020 · Backend Development

Comprehensive Netty Tutorial for Beginners: Installation, Core Concepts, and a Simple String Transmission Example

This article provides a step‑by‑step Netty tutorial for Java beginners, covering framework basics, installation of JDK, Maven and IDEA, core Netty components, differences between BIO/NIO/AIO, practical usage scenarios, and complete client‑server code to transmit a simple string.

NettyNetwork programmingTutorial
0 likes · 19 min read
Comprehensive Netty Tutorial for Beginners: Installation, Core Concepts, and a Simple String Transmission Example
dbaplus Community
dbaplus Community
Jul 2, 2020 · Backend Development

Why High Concurrency Is Really About Squeezing CPU Performance

The article explains that high concurrency in distributed systems is measured by QPS, but its essence lies in effectively utilizing CPU resources, discusses control‑variable analysis of the HTTP request flow, compares PHP‑Swoole and Java‑Netty implementations, and shows how coroutine‑based designs can dramatically boost throughput when I/O blocking is present.

Backend PerformanceNettySwoole
0 likes · 15 min read
Why High Concurrency Is Really About Squeezing CPU Performance
JavaEdge
JavaEdge
May 6, 2020 · Backend Development

Why Netty Powers High‑Performance Java Network Applications

Netty, a Java‑based asynchronous event‑driven framework created in 2008, offers a unified API for multiple transports, a powerful reactor thread model, built‑in codecs, extensive protocol support, high throughput, low latency, robust error handling, and a vibrant ecosystem adopted by major tech companies and open‑source projects.

AsynchronousEvent-drivenNetty
0 likes · 4 min read
Why Netty Powers High‑Performance Java Network Applications
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Apr 28, 2020 · Backend Development

How Netty Builds and Manages Its Channel Pipeline: Creation, Adding, and Destruction

This article explains Netty's channel pipeline lifecycle—including how the responsibility chain is created during channel initialization, how handlers are added and removed, and how the pipeline is torn down during channel closure—while providing detailed source‑code excerpts and diagrams to illustrate each step.

ChannelPipelineEventLoopHandler
0 likes · 16 min read
How Netty Builds and Manages Its Channel Pipeline: Creation, Adding, and Destruction
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Apr 24, 2020 · Backend Development

How Netty’s EventLoopGroup and EventLoop Drive Scalable Web Services

This article dissects Netty’s core components—EventLoopGroup, EventLoop, ServerBootstrap, and channel lifecycle—explaining their initialization, thread‑binding mechanisms, handler pipelines, and port‑binding process with detailed code excerpts and diagrams to reveal how the framework achieves scalable, reactor‑based networking.

Channel pipelineEventLoopJava networking
0 likes · 21 min read
How Netty’s EventLoopGroup and EventLoop Drive Scalable Web Services
Architecture Digest
Architecture Digest
Apr 18, 2020 · Backend Development

Understanding Zero-Copy in Java: Concepts, Implementations, and Netty

This article explains the fundamentals of zero‑copy I/O, covering buffer and virtual memory concepts, Java NIO mechanisms such as MappedByteBuffer and DirectByteBuffer, channel‑to‑channel transfers, and how Netty implements zero‑copy with composite buffers, providing code examples and diagrams for each technique.

NettyZero Copyjava
0 likes · 14 min read
Understanding Zero-Copy in Java: Concepts, Implementations, and Netty
Xiaokun's Architecture Exploration Notes
Xiaokun's Architecture Exploration Notes
Apr 16, 2020 · Backend Development

Unlock Netty’s Core: Deep Dive into ServerBootstrap, EventLoop, and ByteBuf

This article provides a comprehensive walkthrough of Netty’s core components—including ServerBootstrap, EventLoop, Channel, ChannelFuture, ChannelHandler, and ByteBuf—illustrated with a simple server example, code snippets, diagrams, and detailed explanations of threading, zero‑copy, and pipeline processing.

ByteBufEventLoopNetty
0 likes · 30 min read
Unlock Netty’s Core: Deep Dive into ServerBootstrap, EventLoop, and ByteBuf
Java Captain
Java Captain
Apr 7, 2020 · Backend Development

Zero‑Copy Techniques in Java: I/O Concepts, mmap, Sendfile, and Netty

This article explains the zero‑copy principle, describes core I/O concepts such as buffers and virtual memory, and details Java implementations including mmap + write, Sendfile, MappedByteBuffer, DirectByteBuffer, channel‑to‑channel transfer, and Netty’s composite buffers for high‑performance data transfer.

NettyZero Copyjava
0 likes · 12 min read
Zero‑Copy Techniques in Java: I/O Concepts, mmap, Sendfile, and Netty
Programmer DD
Programmer DD
Mar 12, 2020 · Backend Development

Understanding Java NIO vs IO: Channels, Buffers, and Performance

This article explains the fundamental differences between Java NIO and traditional IO, introduces channels and buffers, describes NIO's internal mechanisms, provides a complete code example, and compares NIO's workflow with Netty's model for high‑performance backend development.

BackendBuffersChannels
0 likes · 11 min read
Understanding Java NIO vs IO: Channels, Buffers, and Performance
Java Captain
Java Captain
Mar 7, 2020 · Backend Development

Understanding the Netty Server Startup Process

This article explains how Netty initializes and starts a server by detailing the creation of EventLoopGroups, the configuration of ServerBootstrap, the execution of channel(), handler(), childHandler(), and doBind() methods, and the handling of JDK selector bugs, illustrated with code and diagrams.

EventLoopNettyNetworking
0 likes · 10 min read
Understanding the Netty Server Startup Process
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 24, 2020 · Backend Development

Netty Overview: Architecture, Features, and Performance

This article provides a comprehensive introduction to Netty, covering its core concepts, architecture, threading model, zero‑copy mechanisms, serialization options, comparison with JDK NIO and Tomcat, and practical usage scenarios for building high‑performance asynchronous network applications in Java.

AsynchronousNettyNetworking
0 likes · 35 min read
Netty Overview: Architecture, Features, and Performance
Selected Java Interview Questions
Selected Java Interview Questions
Feb 17, 2020 · Backend Development

Understanding Zero‑Copy and CompositeChannelBuffer in Netty

This article explains the concept of zero‑copy, how Netty implements it through sendfile, FileChannel.transferTo and CompositeChannelBuffer, and provides detailed code analysis of CompositeChannelBuffer's internal structures and lookup algorithms to improve network I/O performance.

CompositeChannelBufferNettyZero Copy
0 likes · 9 min read
Understanding Zero‑Copy and CompositeChannelBuffer in Netty
macrozheng
macrozheng
Jan 9, 2020 · Backend Development

Unlock High‑Performance Networking: Understanding Netty’s Core Architecture

This article explains how Netty, an asynchronous event‑driven framework built on Java NIO, powers high‑throughput RPC systems by detailing its core components, data handling with ByteBuf, and practical client‑server examples, offering developers a clear roadmap for building efficient distributed services.

AsynchronousBootstrapByteBuf
0 likes · 17 min read
Unlock High‑Performance Networking: Understanding Netty’s Core Architecture
dbaplus Community
dbaplus Community
Dec 10, 2019 · Databases

Unveiling Sharding-Proxy: Transparent Database Sharding in Apache ShardingSphere

This talk walks through Sharding-Proxy’s role within Apache ShardingSphere, detailing its architecture, SQL lifecycle from protocol decoding to routing, rewriting, execution, and result merging, while highlighting core principles, performance bottlenecks, and practical optimization techniques for high‑throughput, low‑latency database proxying.

Distributed TracingNettySQL Routing
0 likes · 17 min read
Unveiling Sharding-Proxy: Transparent Database Sharding in Apache ShardingSphere
Tech Musings
Tech Musings
Oct 20, 2019 · Backend Development

How Netty Supercharges ThreadLocal with FastThreadLocal – Inside the Code

This article dissects Netty's custom FastThreadLocal and FastThreadLocalThread implementations, showing how they replace JDK ThreadLocal with constant‑time indexed access, padding to avoid false sharing, and customizable initialization and cleanup to boost backend concurrency performance.

FastThreadLocalNettyThreadLocal
0 likes · 16 min read
How Netty Supercharges ThreadLocal with FastThreadLocal – Inside the Code
Big Data Technology & Architecture
Big Data Technology & Architecture
Sep 13, 2019 · Backend Development

Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty

This article compiles essential Java interview questions covering language fundamentals, core APIs, collections, concurrency mechanisms, JVM internals, design patterns, database concepts, and Netty networking, providing a thorough reference for candidates preparing for backend development positions.

Design PatternsInterview PreparationJVM
0 likes · 12 min read
Comprehensive Java Interview Topics: Language Basics, Collections, Concurrency, JVM, Design Patterns, MySQL, and Netty
Java Captain
Java Captain
Sep 3, 2019 · Backend Development

Getting Started with Bitchat: A Netty‑Based Instant Messaging Framework

This guide introduces Bitchat, a Netty‑based IM framework, showing how to start the server and client, use built‑in commands for login, user listing and private messaging, explains its architecture, custom protocol, health‑check mechanisms, and how to handle business logic with asynchronous thread pools.

FrameworkIMNetty
0 likes · 12 min read
Getting Started with Bitchat: A Netty‑Based Instant Messaging Framework
Java Backend Technology
Java Backend Technology
Aug 19, 2019 · Backend Development

Unlocking Netty’s ByteBuf: How Pooled Off‑Heap Memory Allocation Works

This article demystifies Netty’s ByteBuf pooling mechanism, explaining how off‑heap memory is allocated and managed through PooledByteBufAllocator, detailing the internal structures such as PoolThreadCache, PoolArena, PoolChunk, and Subpage, and providing code examples to illustrate allocation and release processes.

ByteBufMemory PoolingNetty
0 likes · 10 min read
Unlocking Netty’s ByteBuf: How Pooled Off‑Heap Memory Allocation Works
NetEase Game Operations Platform
NetEase Game Operations Platform
Jun 1, 2019 · Cloud Native

Analyzing the Openflowplugin Handshake Process in Opendaylight

This article provides a detailed walkthrough of the Openflowplugin handshake in Opendaylight, explaining how the TCP server is started, how channels are initialized, how listeners are registered, how the hello exchange and version negotiation are performed, and how the controller finalizes the handshake by requesting features and sending a barrier message to the switch.

HandshakeNettyOpenDaylight
0 likes · 10 min read
Analyzing the Openflowplugin Handshake Process in Opendaylight