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.
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.
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×.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
