Tagged articles
memory pool
31 articles · Page 1 of 1
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.
ChannelPipelineJava NIONetty
0 likes · 14 min read

The article explains why high‑concurrency programs suffer from memory fragmentation and system‑call overhead, compares memory pools and object pools, outlines their distinct use‑cases, provides step‑by‑step C and C++ implementations, and highlights optimization tips and common pitfalls.
C++high concurrencymalloc
0 likes · 20 min read

The article explains why Nginx can sustain tens of thousands of simultaneous connections by using non‑blocking sockets, an epoll‑driven event loop, a fixed pool of worker processes, shared memory and memory‑pool optimizations, contrasting this design with Apache's prefork model.
Epollevent-drivenhigh concurrency
0 likes · 5 min read

A newly disclosed nginx‑poolslip 0‑day RCE affecting NGINX 1.31.0 targets the internal memory‑pool, requires a rare non‑default configuration, and while no public PoC exists, analysis of 4,000 real configurations found none exploitable, prompting specific mitigation steps.
0dayConfigurationRCE
0 likes · 9 min read

The article explains how frequent dynamic allocations cause external and internal memory fragmentation, illustrates the problem with C++ examples, and shows that pre‑allocating a large contiguous block as a memory pool—managed via block division, free‑list tracking, and thread‑safe operations—significantly reduces fragmentation, improves allocation speed, and boosts concurrency performance.
C++Low-Level ProgrammingMultithreading
0 likes · 30 min read

This article explains how Netty leverages Linux epoll, a reactor thread model, zero‑copy techniques, custom memory pools, and careful OS/JVM tuning to enable a single server to handle up to a million simultaneous connections efficiently.
EpollNettyPerformance Tuning
0 likes · 8 min read

This article provides a detailed analysis of smart-socket’s memory‑pool mechanism, covering its core classes (BufferPagePool, BufferPage, VirtualBuffer), allocation strategies, configuration tips, code examples, best‑practice recommendations, and the performance benefits such as reduced GC pressure and higher allocation efficiency.
BufferPagePoolGC ReductionJava NIO
0 likes · 10 min read

This article explores why efficient memory management is crucial for C++ performance and presents practical strategies—including stack allocation, RAII, smart pointers, custom memory pools, optimal containers, move semantics, and diagnostic tools—to write faster, more robust programs.
C++RAIImemory pool
0 likes · 9 min read

This article explains why traditional C++ new/delete memory management leads to internal and external fragmentation and performance loss, introduces the concept and principles of memory pools, compares various pool implementations, and provides a complete, thread‑safe example that integrates with std::allocator for high‑efficiency allocation.
C++allocatorfragmentation
0 likes · 29 min read

This article explains why frequent dynamic memory allocation can cause slowdown and fragmentation, introduces fixed-size memory pools as an efficient solution, details their core principles, data structures, key allocation and deallocation functions, and demonstrates their performance advantage with C++ code examples and benchmarks.
C++custom allocatorfixed-size allocation
0 likes · 20 min read

This article explains the problems of memory fragmentation and allocation inefficiency in C++ programs, introduces the concept of memory pools, discusses their design principles, advantages, and common implementations, and provides a complete example of a thread‑safe fixed‑size memory pool with code.
C++allocatormemory pool
0 likes · 29 min read

The article explains how memory pools reduce allocation overhead and fragmentation by pre‑allocating large memory blocks, describes their implementation in C++ and the Linux kernel, compares various pool designs, and shows practical scenarios where pools improve performance and stability.
C++Linux kernelallocation
0 likes · 37 min read

This article explains the concept of memory pools, how they reduce allocation overhead and fragmentation compared to traditional malloc/new, describes various pool designs and Linux kernel APIs, provides multiple C and C++ implementations, and discusses performance benefits and typical application scenarios such as servers, real‑time and embedded systems.
C++ConcurrencyLinux kernel
0 likes · 40 min read

This article adds a missing section on Netty 4.1.112.Final memory pool metrics, detailing the various Metrics classes for PooledByteBufAllocator, PoolArena, PoolSubpage, PoolChunkList, and PoolChunk, and includes code examples for each.
backend-developmentmemory pool
0 likes · 6 min read

The article dissects glibc's ptmalloc implementation, explaining malloc_state, malloc_chunk, fastbins, bins, and top chunk, then analyzes lock contention and fragmentation in multithreaded scenarios through a custom stress test, and concludes with recommendations for high‑performance memory management.
Concurrencyglibchigh-performance
0 likes · 12 min read

This article explores the internal structure and growth mechanism of Go's bytes.Buffer, demonstrates how the GWS library replaces gorilla/websocket, and presents a high‑performance bytes.Buffer pool implementation using sync.Pool with power‑of‑two sizing to reduce allocations and improve concurrency in backend services.
Gobytes.Buffermemory pool
0 likes · 25 min read

This article explains the concept, benefits, and implementation details of memory pools in the Linux kernel, covering allocation functions, design principles, common strategies, and a thread‑safe C++ memory‑pool class with example code.
C++Linux kernelallocation
0 likes · 27 min read

This article presents a comprehensive design and implementation of a high‑concurrency memory pool in C++, covering concepts such as fixed‑size block allocation, thread‑local caches, central and page caches, lock‑free techniques, span management, and performance benchmarking against standard malloc.
C++ConcurrencyThread Cache
0 likes · 57 min read

This article explains the concept of pooling technology, its advantages, and its practical applications in Java—including thread pools, memory pools, database connection pools, and HttpClient connection pools—while highlighting how these techniques improve performance, resource utilization, and system stability.
Javaconnection poolmemory pool
0 likes · 10 min read

This article breaks down Nginx’s high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool strategy, and explains how each component contributes to scalability, low latency, and efficient resource utilization.
BackendProcess Modelarchitecture
0 likes · 10 min read

This article explains how Nginx achieves high performance through its modular design, event‑driven architecture, multi‑stage asynchronous request handling, master‑worker process model, and efficient memory‑pool implementation, contrasting it with traditional web servers and illustrating each concept with diagrams.
Backend PerformanceProcess Modelevent-driven architecture
0 likes · 9 min read

This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool implementation, illustrating how these components together achieve scalability and low latency.
backend developmentmemory poolmodular architecture
0 likes · 10 min read

This article explains how Kafka's producer uses a memory pool to reuse RecordBatch objects, detailing the allocation and deallocation mechanisms, lock handling, and conditions that prevent full garbage collection pauses, thereby improving throughput and resource efficiency.
ConcurrencyFull GCJava
0 likes · 10 min read

Although malloc is a universal allocator, its lack of scenario-specific optimization makes it unsuitable for high‑performance server applications; this article explains malloc’s internal workflow, compares it with custom memory‑pool techniques, and details various pool designs, thread‑safety strategies, and an interesting cross‑thread free problem.
C++backend developmentmalloc
0 likes · 14 min read


58 TechOct 21, 2020 · Backend Development
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.
JavaNettygarbage collection
0 likes · 21 min read

This article explains the concept of pooling—pre‑creating reusable resources—and demonstrates how thread pools, memory pools, database connection pools, and HttpClient pools improve Java application performance, backed by code examples and benchmark results.
memory poolpoolingthread pool
0 likes · 11 min read

This article explains the concept of pooling technology in Java, illustrating its benefits through real‑world analogies, detailing thread pools, memory pools, database connection pools, and HttpClient pools, and provides a performance comparison between raw threads and thread pools using a Java benchmark.
BackendJavaconnection pool
0 likes · 11 min read

This article explains Nginx's high‑performance architecture, covering its modular design, event‑driven processing, multi‑stage asynchronous request handling, master‑worker process model, and memory‑pool mechanism, and compares it with traditional web servers.
Process Managementevent-driven architecturememory pool
0 likes · 10 min read

This article details a competition‑level solution that implements a high‑throughput HTTP server using a custom multi‑threaded epoll model, UDP‑based protocol conversion, sparse indexing, and optimized write‑read schemes to achieve top performance on limited‑resource hardware.
EpollUDPbackend optimization
0 likes · 18 min read

The article analyzes why Go's ioutil.ReadAll becomes a performance bottleneck in IO‑intensive workloads after CPU microcode patches, explains the underlying buffer reallocations, and presents a multi‑level memory‑pool design that reduces allocations and achieves roughly a 19‑fold speedup.
BackendBenchmarkioutil.ReadAll
0 likes · 7 min read


ITPUBNov 6, 2016 · Fundamentals
This article explains the concept of Linux kernel memory pools, details the mempool_t structure, shows how to create and destroy a mempool, and walks through the allocation and free functions with code examples, highlighting their role in preventing allocation failures under memory pressure.
C++Mempoolmemory pool
0 likes · 8 min read
