0 views collected around this technical thread.
This article explains the limitations of traditional I/O models, introduces epoll as a high‑performance Linux I/O multiplexing mechanism, details its design principles, API usage, kernel data structures, and provides practical coding examples and optimization tips for building scalable backend services.
Linux treats all I/O devices as files, enabling a single thread to monitor many descriptors via I/O multiplexing; while select and poll use linear scans and suffer size limits, epoll employs an event‑driven red‑black tree with edge‑triggered mode, offering scalable, high‑performance handling for thousands of concurrent connections.
epoll is a high‑performance Linux I/O multiplexing mechanism that replaces select/poll by using an event‑driven design with a red‑black tree and ready list, supporting edge‑ and level‑triggered modes, efficient data transfer via mmap, and providing superior scalability for high‑concurrency network applications.
Redis achieves remarkable speed through in‑memory storage, I/O multiplexing, optimized data structures such as SDS strings, linked lists, ziplists, skip‑lists, and hash tables, a single‑threaded event loop, and intelligent data encoding, all of which eliminate disk I/O and reduce overhead.
This article explains how epoll improves Linux I/O multiplexing by using red‑black trees and ready lists, compares level‑triggered and edge‑triggered modes, details the epoll_create/epoll_ctl/epoll_wait system calls, discusses common pitfalls, and provides a complete TCP server example for handling many concurrent connections.
Redis achieves remarkable speed by storing data entirely in memory, employing a single‑threaded event loop with I/O multiplexing, and using highly optimized in‑memory data structures while balancing durability through efficient persistence mechanisms, all of which combine to minimize latency and maximize throughput.
This article explains the principles, advantages, and implementation details of Linux's epoll I/O multiplexing mechanism, compares it with select and poll, describes its level‑ and edge‑triggered modes, and provides practical C and Python examples for building high‑concurrency network servers.
This article explains the concepts of level‑triggered (LT) and edge‑triggered (ET) event notification in Linux epoll, describes epoll's core data structures such as the red‑black tree and ready‑list, details the three main APIs (epoll_create, epoll_ctl, epoll_wait), and examines the locking and internal kernel mechanisms that enable efficient I/O multiplexing.
This article explains how Redis achieves extremely high throughput—over 800 k QPS for simple commands and up to 1 M QPS with pipelining—through its C implementation, in‑memory data store, single‑threaded event loop, I/O multiplexing, and optional multithreaded I/O introduced in later versions.
This article provides an in-depth review of common Java backend interview questions, covering alternative object creation methods, practical reflection scenarios, serialization techniques, garbage‑collection algorithms, I/O multiplexing mechanisms, network port listening, and troubleshooting tips for server‑client communication issues.
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.
This article systematically explains epoll's core data structures—including a red‑black tree and a doubly linked ready list—its three main APIs, the kernel implementation details, thread‑safety mechanisms, ET vs. LT behavior, and how it improves over select/poll for high‑concurrency network programming.
This article explains the historic C10K problem of handling ten thousand concurrent connections, compares traditional BIO with modern I/O models such as NIO, select, poll, epoll, and AIO, and provides Java and C++ code examples illustrating how each model improves scalability and performance.
This article explains the evolution of I/O multiplexing in Java, covering the birth of multiplexing, the introduction of NIO with Selector, and detailed comparisons of select, poll, and epoll mechanisms, including their APIs, internal workings, and performance considerations for high‑concurrency network programming.
Virtual memory extends limited physical RAM by giving each process a large address space translated via page tables and a TLB, while multi‑level tables manage size, and the OS separates kernel and user space, offering blocking/non‑blocking, synchronous/asynchronous, multiplexed I/O, reactor patterns, and zero‑copy techniques to optimize data transfer.
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.
This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.
This article explains how Redis evolved from a single‑threaded event‑loop architecture using I/O multiplexing and the Reactor pattern to a multi‑threaded I/O model and an enhanced BIO system with lazyfree, detailing design decisions, source‑code excerpts, performance impacts, and practical lessons for developers.
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.
Redis achieves high performance by storing all data in memory, using compact data structures such as SDS, ziplist and skiplist, running a single‑threaded event loop with lock‑free execution, and employing efficient I/O multiplexing and incremental rehash techniques to minimize latency and maximize throughput.