Tagged articles
thread model
40 articles · Page 1 of 1
The article explains why the traditional one‑request‑one‑thread model collapses at tens of thousands of connections due to memory, scheduling and cache costs, and shows how user‑space coroutine scheduling, stack‑less designs, Go's GMP model, Java virtual threads and CSP channels enable millions of concurrent connections with synchronous‑style code while highlighting trade‑offs and pitfalls.
CSPCoroutinesGo
0 likes · 21 min read

An online gateway crashed despite low CPU and memory because its one‑connection‑one‑thread BIO model exhausted threads, prompting a deep dive into thread‑pool limits, epoll, Reactor patterns, Proactor, and back‑pressure, showing how each evolution decouples connections from resource consumption to achieve million‑QPS scalability.
BIOEpollReactor
0 likes · 18 min read


21CTOJul 19, 2026 · Databases
The pgrust project rewrites PostgreSQL's core in Rust, passes all 46,066 official regression tests, supports standard SQL and the psql client, but remains experimental, exploring a thread‑per‑connection model and showcasing how AI‑driven coding can lower the cost of large‑scale infrastructure rewrites.
AIPostgreSQLRust
0 likes · 15 min read

This article breaks down Redis’s core mechanisms—including its single‑threaded performance tricks, AOF and RDB persistence designs, and the evolution of high‑availability from replication to Sentinel and Cluster—using four clear diagrams to help readers master the system.
AOFClusterHigh Availability
0 likes · 6 min read

Redis achieves million‑level concurrency by keeping all data in RAM, using epoll/kqueue for non‑blocking I/O, employing highly optimized data structures with O(1) or O(log N) operations, and evolving from a single‑threaded core to optional multi‑threaded I/O, boosting throughput up to 12×.
I/O multiplexingIn-MemoryRedis
0 likes · 4 min read

This article explains how Redis handles concurrency, clarifying that core command processing remains single‑threaded while multi‑threaded I/O was introduced in Redis 6.0, and provides interview insights, architectural evolution, configuration examples, best practices, and common pitfalls.
Best PracticesConfigurationMulti-thread I/O
0 likes · 11 min read

This article explains how to maximize throughput and minimize latency of the smart‑socket Java AIO framework by configuring thread counts, applying thread affinity, adjusting read/write buffer sizes, using memory pools, conducting benchmark tests, monitoring runtime metrics, and fine‑tuning JVM options for high‑concurrency, low‑latency network applications.
JVM tuningPerformance Tuningbuffer optimization
0 likes · 11 min read

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 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.
ConcurrencyEventLoopJava
0 likes · 5 min read

The article explains MySQL InnoDB’s multi‑thread architecture—including the Master, IO, Purge, and Page Cleaner threads—detailing each thread’s responsibilities, configurable parameters, and how they cooperate to achieve high‑performance, concurrent data reads and writes while maintaining consistency and crash recovery.
ConcurrencyDatabase PerformanceInnoDB
0 likes · 11 min read

This article explains Tomcat’s embedded core thread architecture, detailing the roles of Acceptor, Poller, and worker threads, their interaction with TCP connection queues, and how network I/O and large responses are processed, supplemented with code excerpts and diagrams.
Acceptor ThreadPoller ThreadTomcat
0 likes · 3 min read

The article examines PostgreSQL's traditional process‑oriented architecture, compares it with a proposed thread‑based model, outlines the advantages and disadvantages of each, and discusses community perspectives on transitioning to threads for improved performance and resource efficiency.
Database ArchitecturePostgreSQLProcess Model
0 likes · 6 min read


ITPUBMar 15, 2023 · Databases
This article explores Redis’s evolution from its 2009 inception, outlines major version releases, examines its in‑memory design, efficient data structures, encoding schemes, single‑threaded event loop with epoll, and benchmark results, illustrating why Redis achieves exceptionally high throughput and low latency in real‑world deployments.
Redisbenchmarkencoding
0 likes · 15 min read

This article explains Redis's rapid growth from its 2009 inception, outlines its version history and popularity, and details the architectural choices—memory‑first design, efficient data structures, smart encoding, and a single‑threaded I/O multiplexing model—that together give Redis its exceptional performance.
data structuresin-memory databasethread model
0 likes · 13 min read

This article walks through Dubbo’s RPC communication using a packet‑as‑narrator metaphor, detailing the thread models of Netty 3 and Netty 4, OS socket handling, and practical troubleshooting steps for latency and timeout issues in a clear, engaging style.
DubboIONetty
0 likes · 11 min read

The article details Redis’s internal architecture, explaining how strings use SDS structures, sorted sets rely on skip‑lists, integers are stored in compact intsets, hash tables employ incremental rehashing, ziplist and listpack provide memory‑efficient encodings, the RAX radix tree underpins key lookup and streams, and the threading model has evolved from a single‑threaded event loop to multithreaded I/O for improved concurrency.
RedisSkip ListStream
0 likes · 35 min read

This article presents a simulated interview that explains Redis's evolution from single‑threaded to optional multithreading, its in‑memory performance advantages, persistence options (AOF, RDB, hybrid), high‑availability architectures, and the consistent‑hashing based slot allocation used by Redis Cluster.
AOFClusterHigh Availability
0 likes · 9 min read

This article explains Redis's high‑performance I/O architecture by tracing the evolution from blocking, non‑blocking, and multiplexed network models to various Reactor‑based thread designs, illustrating each model with Java pseudo‑code and diagrams to clarify why Redis adopts a single‑threaded Reactor with optional multi‑threaded I/O extensions.
JavaReactor PatternRedis
0 likes · 19 min read

The article thoroughly examines Redis’s high‑performance architecture, detailing the evolution from blocking to non‑blocking I/O, the Reactor pattern’s single‑ and multi‑reactor models, Redis’s I/O multiplexing thread design, and how its hybrid single‑thread core with auxiliary I/O threads mitigates bottlenecks under heavy traffic.
I/O multiplexingReactor PatternRedis
0 likes · 16 min read

This article explains server thread models—including traditional blocking I/O, the Reactor pattern with its single‑thread, multi‑thread, and master‑slave variants, and the asynchronous Proactor model—detailing their mechanisms, advantages, disadvantages, and typical use cases in backend development.
Reactor Patternasynchronous I/Onetwork programming
0 likes · 12 min read

This article explains how servers handle requests using process/thread models, covering traditional blocking I/O, the Reactor pattern with its single‑thread, multi‑thread, and master‑slave variants, and the Proactor model, while comparing their advantages, drawbacks, and typical use cases.
ConcurrencyProactorReactor Pattern
0 likes · 12 min read

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

This article explains Netty’s core architecture and its master‑worker multi‑reactor thread model, detailing the roles of Acceptor, Main Reactor, and Sub Reactor, how connection handling, I/O, encoding/decoding, and business logic are coordinated across threads, and provides practical insights for interview preparation.
Java NIOReactor Patternbackend development
0 likes · 11 min read


ITPUBDec 7, 2020 · Databases
This article explains how Redis achieves high performance by using an in‑memory architecture, specialized data structures such as SDS, doubly linked lists, ziplists and skip‑lists, efficient encoding strategies, and a single‑threaded I/O multiplexing model that eliminates costly context switches.
Backenddata structuresin-memory database
0 likes · 12 min read

This article explains Redis's event-driven architecture, detailing file and time events, their processing flow, and why Redis 6.0 introduced multithreading to improve network I/O while keeping command execution single‑threaded.
File EventsRedisTime Events
0 likes · 8 min read

This article shares the author's exploration of in‑memory search engine design, covering system understanding, core architecture, thread and task models, intersection algorithms, lookup optimizations, and componentization, aiming to fill the scarce documentation on memory‑based retrieval engines.
IndexingQuery ProcessingTask Scheduling
0 likes · 48 min read


JavaEdgeOct 30, 2020 · Backend Development
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.
EventLoopJavaNetty
0 likes · 11 min read

This article details how Ctrip optimized the CAT monitoring system—covering its large‑scale deployment, thread‑model redesign, offloading calculations to clients, double‑buffered reporting, and string handling improvements—to dramatically cut CPU usage, GC pressure, and memory consumption while handling billions of messages daily.
GCJavadistributed systems
0 likes · 25 min read

This guide explores Redis key expiration policies—including active, lazy, and periodic expiration—memory eviction strategies, resource consumption, thread model, and transaction mechanisms, providing practical insights on configuring TTL, optimizing memory usage, and understanding Redis’s single‑threaded architecture for reliable data handling.
RedisTransactionsexpiration
0 likes · 12 min read

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

This article details Ctrip's implementation and performance optimization of the CAT application monitoring system, covering its deployment, thread‑model redesign, client‑side computation offloading, double‑buffered reporting, and string handling improvements that reduced CPU usage and GC pressure.
CATGCJava
0 likes · 23 min read

RND (React Node Desktop) is a lightweight cross‑platform desktop framework that merges a React‑based JavaScript layer, an embedded V8‑powered Node runtime, and a native UI engine (Lyra with Yoga layout), employing a dual‑thread model, shared V8 isolate, asynchronous bridge, modular resource handling with hot‑update, and integrated Chrome/VSCode/Electron debugging.
JavaScriptRNDReact Node Desktop
0 likes · 14 min read

This article explains what Redis is, how it is used for caching in projects, the performance and concurrency advantages of caching, common cache pitfalls, key differences between Redis and Memcached, and the internal single‑threaded event‑driven architecture that enables high‑throughput operations.
MemcachedRedishigh concurrency
0 likes · 11 min read

This article explains what Redis is, how it is used for caching in projects, the advantages of caching, common cache issues, key differences between Redis and Memcached, and why Redis's single‑threaded design can still support high concurrency.
Memcached ComparisonRedisin-memory database
0 likes · 9 min read

This article explains how servers manage connections using different I/O and thread models—including traditional blocking I/O, the Reactor pattern with its single‑thread, multi‑thread, and master‑slave variants, and the Proactor model—highlighting their advantages, drawbacks, and typical use cases in backend development.
I/O ModelsReactor Patternnetwork programming
0 likes · 10 min read

By refactoring Xianyu’s key features with RxJava 2.0, the team replaced blocking logging, HTTP, RPC, and cache operations with asynchronous streams, cutting response time by half, boosting CPU utilization to 97%, raising throughput about 30%, and demonstrating a unified, core‑size thread‑pool model.
BackendReactive ProgrammingRxJava
0 likes · 9 min read

This article explains Go's concurrency foundations, detailing the difference between concurrency and parallelism, the CSP model using goroutines and channels, and the internal M‑P‑G scheduler architecture that balances work across processors and system threads.
CSPConcurrencyGo
0 likes · 9 min read

This article explores server I/O models—including single‑thread blocking, multi‑thread blocking, single‑thread non‑blocking, and multi‑thread non‑blocking (Reactor) approaches—detailing their mechanisms, advantages, drawbacks, and how kernel‑level event detection improves performance, helping developers choose the right model for various scenarios.
Reactor Patternbackend developmentblocking I/O
0 likes · 16 min read

This article introduces Netty, an asynchronous event‑driven network framework, covering its design goals, performance benefits, core components such as zero‑copy and unified APIs, advanced features like SSL/TLS and WebSocket support, and explains its single‑thread, multi‑thread, and master‑slave thread models for high‑concurrency backend development.
NettyWebSocketbackend development
0 likes · 9 min read

The article examines why upgrading from Netty 3.x to 4.x can cause severe performance drops, analyzes thread‑model changes, GC overhead, context loss, and provides detailed comparisons of inbound/outbound processing, concluding with best‑practice recommendations for safe migrations.
BackendJavaNetty
0 likes · 16 min read
