Tagged articles
single-thread
28 articles · Page 1 of 1
TrueAsync Server is a high‑performance HTTP/1.1, HTTP/2 and HTTP/3 server written in C that embeds directly into the PHP process, runs entirely on a single thread, eliminates inter‑thread communication, supports multi‑protocol on one port, and offers a suite of low‑level optimizations and a clear API for developers.
BackendC++HTTP/3
0 likes · 17 min read

The article explains how Redis achieves more than 100,000 queries per second by leveraging in‑memory storage, highly optimized data structures, a single‑threaded core with epoll‑based I/O multiplexing, optional I/O multithreading, and performance tricks such as pipelining and careful key sizing.
I/O multiplexingPipelineQPS
0 likes · 9 min read

Redis can sustain over 100,000 queries per second thanks to four key factors: pure in‑memory storage, highly optimized data structures such as SDS and ziplist, a single‑threaded event loop with epoll‑based I/O multiplexing, and optional multi‑threaded network handling introduced in Redis 6.0.
IO MultiplexingQPSdata structures
0 likes · 10 min read

Redis can sustain over 100,000 queries per second thanks to four key pillars—memory‑first storage, highly optimized data structures like SDS and skip lists, a single‑threaded event loop with epoll multiplexing, and multi‑core I/O threading—each explained with benchmarks, code samples, and real‑world comparisons.
IO MultiplexingPipelineQPS
0 likes · 10 min read

The article explains how Redis attains up to 500,000 queries per second on a single node by leveraging ultra‑fast in‑memory access, a single‑threaded core for data operations, and epoll‑based I/O multiplexing that eliminates per‑connection thread overhead.
EpollI/O multiplexinghigh-performance
0 likes · 4 min read

Redis achieves single‑machine million‑level QPS not merely because it stores data in memory, but through a tightly coordinated set of four core design principles—pure in‑memory operation, single‑threaded architecture, I/O multiplexing, and highly optimized data structures—that together deliver ultra‑low latency and massive throughput.
In-Memorydatabasesredis
0 likes · 5 min read

This article explains why Redis can handle massive concurrent traffic by storing all data in RAM, using a single‑threaded event loop, leveraging Linux epoll for I/O multiplexing, and employing highly optimized in‑memory data structures that keep latency in the microsecond range.
data structuresin-memory databaseperformance
0 likes · 5 min read

This article explains why Redis achieves extremely high performance, reaching up to 100,000 QPS, by leveraging its in‑memory design, I/O multiplexing, optimized data structures such as SDS, ziplist and skiplist, and a single‑threaded event loop, each detailed with examples and code.
In-Memoryperformanceredis
0 likes · 6 min read

The article explains how Redis achieves high QPS by using an in‑memory, single‑threaded event loop for simple commands, leverages I/O multiplexing (epoll/select/kqueue) and optional multi‑threaded I/O for heavy operations, and outlines its evolution from a pure reactor model to a hybrid multi‑threaded architecture.
I/O multiplexingMultithreadingdatabases
0 likes · 17 min read

This article explores why Redis delivers ultra‑high performance by examining its in‑memory design, single‑threaded event loop, efficient data structures such as hash tables, SDS strings, ziplist, quicklist, and skiplist, as well as its encoding strategies and I/O multiplexing model.
I/O multiplexingdata structuresin-memory database
0 likes · 21 min read

Redis achieves its remarkable speed through in‑memory storage, an efficient hash table design, single‑threaded execution that eliminates context switches, epoll‑based I/O multiplexing, progressive rehashing, and cached timestamps, all of which together enable near O(1) operations and minimal latency.
Rehashhash tablein-memory database
0 likes · 7 min read

This article explains why Redis achieves exceptional speed by leveraging in‑memory storage, an efficient hash‑table data structure, a single‑threaded event loop, epoll I/O multiplexing, incremental rehashing, and cached timestamps, providing a comprehensive view of its performance optimizations.
EpollIncremental Rehashhash table
0 likes · 7 min read

This article explains why Redis traditionally operates with a single thread, how its memory‑centric design, simple data structures and I/O multiplexing keep it fast, and why newer Redis versions introduced multithreading for network I/O and lazy deletion of large keys.
IO MultiplexingMultithreadingdatabases
0 likes · 9 min read

This article explains how Redis uses Linux epoll and a single‑threaded event loop to handle millions of connections efficiently, covering the creation of the epoll object, server initialization, event registration, the main processing loop, and the mechanisms for reading, writing, and managing pending tasks.
Epollbackend developmentevent-loop
0 likes · 23 min read


ITPUBOct 28, 2023 · Databases
This article explains why Redis, despite being described as single‑threaded, achieves extremely high performance by using a single thread for network I/O and command execution, avoiding multithreading overhead, and leveraging efficient in‑memory data structures together with an event‑driven multiplexing I/O model.
I/O multiplexingdatabasesevent-driven
0 likes · 12 min read

Redis achieves high performance by storing all data in memory, using compact data structures like SDS, linked lists, hash tables, skip lists and integer sets, running a single‑threaded event loop, and handling thousands of client connections with efficient I/O multiplexing.
data structuresin-memory databaseredis
0 likes · 18 min read

Redis achieves exceptional speed by operating as an in‑memory database, leveraging compact data structures like SDS, linked lists, hash tables, skip lists and ziplists, running a single‑threaded event loop with I/O multiplexing, and employing optimizations such as lazy‑free, progressive rehashing, and multithreaded network I/O.
I/O multiplexingdata structuresperformance optimization
0 likes · 18 min read

Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, hash tables, skip‑lists and zip‑lists, running a single‑threaded event loop with I/O multiplexing, and applying optimisations like lazy‑free, progressive rehashing and optional multi‑threaded I/O for network traffic.
I/O multiplexingdata structuresin-memory database
0 likes · 18 min read

This article explains how Redis achieves high‑performance queries by leveraging in‑memory storage, specialized data structures such as SDS, hash tables, skip‑lists and zip‑lists, a single‑threaded event loop with I/O multiplexing, and progressive rehashing techniques.
I/O multiplexingdata structuresin-memory database
0 likes · 18 min read

This article explains why Redis achieves high throughput—up to 100,000 QPS—by leveraging in‑memory storage, simple data structures, a single‑threaded event loop with I/O multiplexing, and the optional multithreaded I/O model introduced in Redis 6.0, including configuration details and safety considerations.
Multithreadingdatabasesperformance
0 likes · 8 min read

This article walks through Redis’s annotated source code to explain how its single‑threaded architecture initializes the server, loads configuration and data, and continuously processes file and time events within a while‑loop, revealing why Redis achieves high performance without spawning additional worker threads.
C++backend developmentevent-loop
0 likes · 9 min read

This article walks through Redis's startup sequence, explaining how the server creates a listening socket, registers events with the aeFileEvent system, runs a single‑threaded select‑based event loop, and processes client commands using the Reactor pattern, complete with code examples and diagrams.
Reactor Patternbackend developmentevent-loop
0 likes · 8 min read

This article explains why Redis achieves exceptionally high performance by combining pure in‑memory operations, a global hash table with O(1) lookups, efficient data structures such as SDS, ziplist, quicklist and skiplist, a single‑threaded event loop with non‑blocking I/O multiplexing, and adaptive encoding strategies.
IO Multiplexingdata structureshash table
0 likes · 20 min read

This article explains why Redis achieves exceptional speed by examining its memory‑only architecture, single‑threaded event loop, and the specialized data structures—global hash tables, SDS strings, ziplist, quicklist, skiplist, and intset—that provide O(1) or O(log N) operations, along with non‑blocking I/O multiplexing.
I/O multiplexingdata structureshash table
0 likes · 20 min read


ITPUBNov 21, 2020 · Backend Development
This article explains how Redis achieves high performance by storing data in memory, using optimized data structures like SDS, linked lists, ziplists, hash tables, and skip lists, and employing an I/O multiplexing single‑threaded reactor model to minimize latency and overhead.
I/O multiplexingdata structuresin-memory database
0 likes · 10 min read


JavaEdgeSep 1, 2020 · Backend Development
This article explains how Redis implements a single‑threaded architecture by using a file event handler built on non‑blocking I/O multiplexing (select, epoll, evport, kqueue), detailing socket event abstraction, the I/O multiplexing program, event dispatcher, and the mapping of various socket operations to specific handlers.
I/O multiplexingevent handlingredis
0 likes · 7 min read

This article explains Redis’s core concepts, data structures, persistence options, and the reasons behind its exceptional speed—including in‑memory operations, simple data models, single‑threaded design, and efficient I/O multiplexing—while also covering common interview questions about caching and Redis’s threading model.
Interviewin-memory databaseredis
0 likes · 10 min read

This article explains Node.js architecture, showing how JavaScript code interacts with the operating system via C/C++ bindings, clarifies the single‑threaded model backed by a thread pool, and details the libuv‑based event loop that enables high‑concurrency non‑blocking I/O.
BackendJavaScript RuntimeNode.js
0 likes · 15 min read
