Tagged articles
I/O multiplexing
89 articles · Page 1 of 1
The article walks developers through the root causes of high CPU consumption when using select/poll, explains why epoll solves these bottlenecks, and provides a complete, pure‑C implementation that covers socket setup, epoll creation, registration, event loops, level‑trigger vs edge‑trigger modes, and performance comparisons.
EpollI/O multiplexingLinux
0 likes · 31 min read

Redis achieves its high speed not only because it is an in‑memory, single‑threaded database with efficient data structures, but primarily thanks to I/O multiplexing, which lets a single thread manage tens of thousands of client connections, dramatically cutting thread‑switch overhead and boosting throughput up to tenfold.
EpollI/O multiplexingevent-driven
0 likes · 4 min read

This article explains the concepts of synchronous vs. asynchronous and blocking vs. non‑blocking I/O, outlines the five Unix I/O models, and then compares select, poll, and epoll—including their internal mechanisms, performance trade‑offs, edge‑ and level‑triggered modes, and why epoll is considered the solution to the C10K problem.
EpollI/O multiplexingLinux
0 likes · 17 min read

The article explains how Nginx’s event‑driven, asynchronous non‑blocking model, master‑worker multi‑process design, efficient I/O multiplexing (epoll/kqueue), and lightweight resource‑control architecture enable it to sustain extremely high concurrency with minimal overhead.
I/O multiplexingNGINXasynchronous
0 likes · 5 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

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

The article dissects Redis’s internal architecture—its single‑threaded model, I/O multiplexing, specialized data structures, persistence mechanisms, Lua scripting, memory management, clustering, and monitoring—explaining how each design choice contributes to extreme performance and outlining the trade‑offs and best‑practice scenarios for using or avoiding Redis.
I/O multiplexingJRedisLua scripting
0 likes · 10 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-Memorydata structures
0 likes · 4 min read

Redis achieves sub‑millisecond response times by storing all data in RAM, using a single‑threaded event loop with I/O multiplexing (epoll/select/poll), and employing highly optimized data structures such as skip lists and hash tables that provide O(1) or O(log N) operations.
I/O multiplexingIn‑memorydata structures
0 likes · 4 min read

Redis delivers millisecond‑level response and millions of operations per second by storing data entirely in memory, using a single‑threaded event‑driven model, efficient I/O multiplexing with epoll, and highly optimized data structures such as strings, hashes, lists, sets and sorted sets.
I/O multiplexingdata structuresin-memory database
0 likes · 4 min read

This article explains how Linux’s epoll mechanism, built on libevent and using red‑black trees and ready‑list queues, provides scalable I/O multiplexing for sockets, eventfd and timerfd while traditional file systems like ext4 cannot be managed directly, and outlines the key efficiency tricks behind its design.
EpollI/O multiplexingLinux
0 likes · 8 min read

The proposal introduces a unified poll API for PHP that replaces the limited stream_select() function with a flexible, platform‑aware interface supporting epoll, kqueue, WSAPoll and other backends, enabling high‑performance, scalable I/O handling for servers and event‑driven applications.
EpollI/O multiplexingPHP
0 likes · 19 min read

This article breaks down Nginx's core concurrency mechanisms—including asynchronous non‑blocking event‑driven processing, the master‑worker process model, epoll‑based I/O multiplexing, and its lightweight design—showing how it efficiently serves massive traffic with minimal resources.
BackendI/O multiplexingNGINX
0 likes · 5 min read

Redis achieves million‑level concurrency by storing all data in memory, leveraging ultra‑fast read/write speeds, employing optimized data structures such as strings, hashes, lists, sets and sorted sets, using I/O multiplexing to handle many connections in a single thread, and scaling through master‑slave replication for high availability.
I/O multiplexingReplicationdata structures
0 likes · 4 min read

epoll, Linux’s high-performance I/O multiplexing mechanism, outperforms select and poll by leveraging a red-black tree to manage file descriptors, offering O(log n) registration, O(1) event retrieval, and scalable handling of millions of connections, with detailed explanations of its architecture, workflow, and performance advantages.
EpollI/O multiplexingLinux
0 likes · 10 min read

This article explains the three‑stage execution flow of a Redis command—connection establishment, command processing, and result return—detailing how the single‑threaded reactor pattern drives event handling, how commands are parsed and dispatched, and how the output is sent back, with code snippets and a comparison to Netty’s multithreaded reactor.
Command ExecutionDatabase InternalsI/O multiplexing
0 likes · 50 min read

This article explains the limitations of traditional I/O models such as blocking I/O, non‑blocking I/O, select and poll, introduces epoll’s design, core data structures, operation modes, system‑call interface, and provides practical code examples and optimisation tips for high‑concurrency network servers.
EpollI/O multiplexingLinux
0 likes · 45 min read

This article explores Linux’s epoll interface in depth, covering its core architecture, LT and ET trigger modes, underlying red‑black tree and linked‑list data structures, callback workflow, practical code examples, and best‑practice guidelines for high‑concurrency network applications.
ETEpollI/O multiplexing
0 likes · 33 min read

This comprehensive guide explores C++ multithreaded network programming for high‑concurrency servers, covering threads, processes, socket basics, TCP/UDP protocols, thread pools, synchronization primitives, lock‑free structures, I/O multiplexing techniques, and a practical high‑performance chat server implementation.
C++I/O multiplexingMultithreading
0 likes · 54 min read

This article explains the C10K problem—how a single server can manage ten thousand simultaneous connections—and outlines four essential techniques (I/O multiplexing, asynchronous non‑blocking I/O, lightweight threading models, and network stack optimization) that enable Nginx and similar servers to achieve high concurrency efficiently.
Backend PerformanceC10KI/O multiplexing
0 likes · 4 min read

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.
EpollI/O multiplexingevent-driven
0 likes · 41 min read

In this interview-style article, the interviewer probes a candidate on why Redis is exceptionally fast, covering its in‑memory storage, single‑threaded design, I/O multiplexing, optimized data structures, memory management tricks, and practical performance‑tuning strategies.
I/O multiplexingSingle-Threaded Architecturedata structures
0 likes · 7 min read

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.
EpollI/O multiplexingLinux
0 likes · 30 min read

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.
EpollI/O multiplexingevent-driven
0 likes · 85 min read

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.
I/O multiplexingin-memory databaseredis
0 likes · 8 min read

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.
EpollI/O multiplexingLinux
0 likes · 72 min read

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.
I/O multiplexingIn-Memorydata structures
0 likes · 6 min read

This article explains how epoll works as Linux's high‑performance I/O multiplexer, compares it with select and poll, details its three‑step workflow, data structures, code examples, and the trade‑offs between level‑triggered and edge‑triggered modes for building scalable network servers.
ETEpollI/O multiplexing
0 likes · 22 min read

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.
EpollI/O multiplexingLinux
0 likes · 61 min read

Redis primarily operates with a single thread using I/O multiplexing (select, poll, epoll) to handle massive concurrent connections, while newer versions introduce optional multi‑threaded networking and use child processes for persistence, maintaining its core single‑threaded design for data processing.
Database ArchitectureEpollI/O multiplexing
0 likes · 5 min read

Redis achieves millisecond‑level latency by storing all data in memory, using specially optimized data structures such as SDS, incremental‑rehash hash tables, and ziplists, employing a single‑threaded event‑driven model with epoll‑based I/O multiplexing, and streamlining network communication through the compact RESP protocol, compression, and batching, while also offering flexible eviction and persistence strategies.
Cache EvictionI/O multiplexingdata structures
0 likes · 11 min read

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.
EpollI/O multiplexingLinux kernel
0 likes · 69 min read

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.
I/O multiplexingMultithreadingredis
0 likes · 16 min read

Redis’s core operations run on a single thread to avoid concurrency overhead, while auxiliary tasks use extra threads; the article explains the single‑threaded model, Linux I/O multiplexing (select/epoll), Redis 6.0’s I/O thread feature, and practical configuration steps to improve throughput.
ConfigurationI/O multiplexingredis
0 likes · 8 min read

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.
I/O multiplexingJavaReflection
0 likes · 24 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 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.
EpollI/O multiplexingLinux kernel
0 likes · 68 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

This article explains the separation of user and kernel space, compares blocking, non‑blocking, multiplexed, signal‑driven, and asynchronous I/O models, and details the select, poll, and epoll mechanisms used to efficiently handle multiple file descriptors in Linux.
EpollI/O multiplexingKernel Space
0 likes · 12 min read

This article explains the core concepts of I/O in operating systems, covering blocking I/O, non‑blocking I/O, and I/O multiplexing, their workflows, advantages, disadvantages, and practical analogies to help developers choose the right model for their applications.
I/OI/O multiplexingblocking I/O
0 likes · 8 min read


LouZaiJan 29, 2024 · Interview Experience
This article systematically explains epoll’s internal data structures, how the protocol stack notifies it, the locking strategy for thread safety, the differences between edge‑triggered and level‑triggered modes, and why it outperforms select/poll in high‑concurrency Linux I/O.
EpollI/O multiplexingLinux
0 likes · 13 min read

This article explains Linux file concepts, how file descriptors work, why simple blocking I/O fails at scale, and introduces I/O multiplexing techniques—including select, poll, and epoll—detailing their mechanisms, limitations, and practical code examples for high‑concurrency servers.
EpollI/O multiplexingfile-descriptors
0 likes · 13 min read


政采云技术Nov 14, 2023 · Backend Development
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.
C10KEpollI/O multiplexing
0 likes · 22 min read

This article explains the fundamentals of socket programming, detailing server and client setup steps, the TCP three‑way handshake, criteria for readable and writable sockets, and advanced techniques such as multi‑process models, I/O multiplexing, the Reactor pattern, and Epoll’s role in efficient event‑driven networking.
EpollI/O multiplexingReactor Pattern
0 likes · 9 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

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.
EpollI/O multiplexingNIO
0 likes · 44 min read

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.
I/O multiplexingTLBaddress translation
0 likes · 28 min read

Redis achieves remarkable speed by operating as an in‑memory database, leveraging specialized data structures like SDS, linked lists, hash tables, skip lists, and ziplists, while using a single‑threaded event loop with I/O multiplexing, incremental rehashing, and optimized memory management to minimize latency.
I/O multiplexingin-memory databaseredis
0 likes · 19 min read

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.
I/O multiplexingdata structuresin-memory database
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

This article explains why Redis, originally designed as a single‑threaded in‑memory database, introduced a multithreaded network layer in version 6.0, covering the historical design, the limits of CPU vs I/O utilization, the role of I/O multiplexing, and the benefits and drawbacks of the new model.
ConcurrencyI/O multiplexingMultithreading
0 likes · 11 min read

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.
I/O multiplexingin-memory databaseredis
0 likes · 17 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 the epoll interface, its underlying data structures, the three-step usage pattern, the differences between level‑triggered and edge‑triggered modes, the reactor model, and provides a complete C demo, helping developers efficiently handle millions of concurrent TCP connections on Linux.
EpollI/O multiplexingLinux
0 likes · 17 min read

This article explains why traditional select and poll struggle with many file descriptors, how epoll redesigns the workflow by registering descriptors once via epoll_ctl, the kernel data structures (eventpoll, epitem) that manage events, and walks through the core functions epoll_create, epoll_ctl, epoll_wait, and their callbacks.
C++EpollI/O multiplexing
0 likes · 22 min read

This article explains how epoll solves the inefficiencies of select/poll by using a kernel‑side red‑black tree and ready‑list, details its API, internal structures, trigger modes, reactor model, and provides a complete C demo for building a scalable TCP server.
EpollI/O multiplexingc-programming
0 likes · 17 min read

This article provides a comprehensive source-level analysis of Redis 6.0 and later multi-threaded architecture, detailing how the main event loop coordinates with dedicated I/O threads to efficiently distribute, parse, and process concurrent read and write requests while maintaining high throughput and low latency.
EpollI/O multiplexingc-programming
0 likes · 21 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 traditional select/poll struggle with massive connections, how epoll's event-driven design using a red‑black tree and ready‑list dramatically improves scalability, details its two trigger modes, and provides a complete C demo illustrating a high‑performance reactor model.
BackendEpollI/O multiplexing
0 likes · 18 min read

The article explains how Redis implements a high‑performance single‑threaded architecture by using a Reactor‑style file‑event handler (FEH) built on I/O multiplexing, detailing socket events, the I/O multiplexing program, dispatcher, handler mapping, and the overall client‑server communication flow.
I/O multiplexingevent-drivenredis
0 likes · 9 min read

This article explains why Redis achieves high query performance by leveraging in‑memory storage, specialized data structures such as SDS, linked lists, dictionaries, ziplists and skiplists, a single‑threaded event loop with I/O multiplexing, and various optimization techniques that avoid common bottlenecks.
I/O multiplexingdata structuresin-memory database
0 likes · 18 min read

This article explains how to use Python's socket module together with I/O multiplexing techniques such as select, poll, epoll, and the high‑level selectors module to build non‑blocking, scalable network servers that can handle multiple client connections concurrently.
EpollI/O multiplexingPython
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 Patternhigh-performance
0 likes · 16 min read

Explore the four fundamental I/O models—Blocking, Non‑Blocking, I/O Multiplexing (Reactor), and Asynchronous (Proactor)—with clear explanations and illustrative diagrams, helping readers grasp how each model works, their typical use cases, and why technologies like epoll or Redis benefit from multiplexing.
I/O multiplexingIO modelsasynchronous IO
0 likes · 3 min read

This article explains Redis's clean and elegant I/O multiplexing implementation, covering blocking I/O limitations, the reactor pattern, abstraction of select/epoll/kqueue into a unified API, key source functions, and platform‑specific module selection to achieve high‑performance single‑threaded networking.
EpollI/O multiplexingevent-loop
0 likes · 14 min read

Redis, traditionally single‑threaded for network I/O and key‑value operations, introduced multithreading in version 6.0 to improve network I/O handling; this article explains the original single‑thread design, when multithreading is appropriate, its drawbacks, the role of I/O multiplexing, and why Redis still keeps most work single‑threaded.
Database PerformanceI/O multiplexingMultithreading
0 likes · 12 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

This article explains why Redis is exceptionally fast by detailing its in‑memory design, global hash table with O(1) lookups, incremental rehashing, specialized data structures such as SDS, ziplist, quicklist, skiplist and intset, as well as its single‑threaded event loop and epoll‑based I/O multiplexing.
I/O multiplexinghash tablein-memory database
0 likes · 19 min read

This article provides an in‑depth exploration of Linux’s epoll mechanism, covering its blocking behavior, kernel‑level processing, NAPI optimization, comparisons with select/poll, and practical insights into I/O multiplexing, helping backend engineers understand performance characteristics and design efficient network services.
EpollI/O multiplexingLinux kernel
0 likes · 15 min read

This article explains the four main I/O models—blocking, non‑blocking, multiplexing (reactor), and asynchronous (proactor)—detailing their characteristics, typical implementations in Java and Linux, and when each model is appropriate for building efficient network applications.
I/O multiplexingIO modelsasynchronous I/O
0 likes · 3 min read

The article traces Redis’s shift from its original single‑threaded reactor model to the I/O‑threaded architecture introduced in version 6, explaining how atomic operations and round‑robin client distribution let separate threads handle network I/O and parsing while the main thread executes commands, yielding roughly a two‑fold throughput boost but retaining a single‑threaded command core and incurring brief CPU spikes from busy‑wait synchronization.
I/O multiplexingNetwork ModelReactor Pattern
0 likes · 34 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


JavaEdgeNov 3, 2020 · Backend Development
This article compares Linux's select, poll, and epoll mechanisms, explaining their internal workings, limitations such as FD_SETSIZE and linear scanning, and why epoll's event‑driven design offers superior scalability and performance for high‑concurrency network servers.
EpollI/O multiplexingLinux
0 likes · 7 min read

This article explains the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—detailing their system calls, synchronization concepts, performance characteristics, and how they map to Java BIO, NIO, and AIO implementations.
I/O ModelsI/O multiplexingJava NIO
0 likes · 13 min read

This article explains why Redis, a single‑threaded server, adopts I/O multiplexing to avoid blocking, compares blocking I/O with multiplexed models, and details the internal implementation of select, epoll, and kqueue wrappers that power Redis's high‑performance event loop.
EpollI/O multiplexingevent-loop
0 likes · 14 min read

This article explains the fundamentals of blocking and non‑blocking I/O, compares select, poll, and epoll mechanisms, introduces the Reactor model and its variants, and shows how to solve the C10K problem with processes, threads, thread pools, and event‑driven architectures, complete with code examples.
EpollI/O multiplexingReactor Pattern
0 likes · 28 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 the five I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—detailing their operation, typical applications, advantages, and drawbacks within the Linux/UNIX networking environment, and compares synchronous versus asynchronous I/O concepts.
I/O ModelsI/O multiplexingLinux
0 likes · 11 min read

This article thoroughly examines Linux's epoll mechanism, detailing its SLAB memory management, middle‑layer design, edge and level triggering, comparison with select/poll, and related advanced polling technologies such as /dev/poll and kqueue, while also discussing C10K/C10M challenges and practical solutions.
C10KEpollI/O multiplexing
0 likes · 19 min read

This article provides a comprehensive analysis of Linux's epoll mechanism, covering its fundamental data structures, key kernel functions, wait‑queue handling, event insertion, wake‑up logic, and the differences between edge‑triggered and level‑triggered modes, while including full source code excerpts for reference.
EpollI/O multiplexingLinux
0 likes · 21 min read

This article explains Redis's startup sequence, detailing server initialization, configuration loading, event‑loop creation, supported I/O multiplexing mechanisms, timer and I/O callbacks, and the complete request‑response flow from client command to server reply.
I/O multiplexingServer Initializationbackend development
0 likes · 13 min read

Redis achieves exceptional speed by combining a C‑based implementation, pure in‑memory data storage, a single‑threaded event loop, and non‑blocking epoll I/O multiplexing, while supporting rich data structures and advanced features such as transactions, Lua scripting, and clustering.
I/O multiplexingIn-Memorydatabases
0 likes · 6 min read

This article examines Redis's I/O multiplexing mechanism, explaining why it uses non‑blocking models, detailing the Reactor pattern, comparing select, epoll, and kqueue, and providing a thorough walkthrough of the underlying C code that implements event creation, addition, deletion, and polling across platforms.
EpollI/O multiplexingReactor Pattern
0 likes · 11 min read

This article explains Tomcat's NIO architecture, covering the I/O multiplexing model, Tomcat's support for various I/O models, NioEndpoint component relationships, step‑by‑step source‑code analysis, performance considerations, and practical configuration tips for optimizing high‑concurrency Java servers.
I/O multiplexingJavaNIO
0 likes · 11 min read

This article revisits fundamental network I/O concepts, clarifying the differences between blocking, non‑blocking, synchronous, asynchronous, and multiplexed models through clear explanations and illustrative diagrams, helping developers build a solid mental model of how data moves between processes and the kernel.
I/O multiplexingSystems Programmingasynchronous
0 likes · 8 min read

The article explains how NIO replaces the thread‑intensive blocking I/O model with a non‑blocking, event‑driven architecture that lets a single thread handle many connections, covering BIO vs NIO differences, selector mechanics, Reactor/Proactor patterns, buffer strategies, practical use cases, and framework recommendations.
Buffer ManagementI/O multiplexingJava Networking
0 likes · 19 min read

This article introduces Linux’s epoll mechanism, explains how to create and control epoll instances with epoll_create, epoll_ctl, and epoll_wait, describes the associated data structures and event flags, compares epoll to select, and highlights its O(1) scalability advantages for high‑connection backend applications.
BackendEpollI/O multiplexing
0 likes · 7 min read

This article explains how Redis, a high‑performance in‑memory database, uses a single‑process single‑thread architecture combined with the Reactor pattern and I/O multiplexing techniques such as select, poll, epoll, and kqueue to efficiently handle massive client connections.
BackendI/O multiplexingReactor Pattern
0 likes · 12 min read

This article explains how Redis, a single‑process single‑threaded in‑memory database, uses the Reactor pattern and various I/O multiplexing techniques such as select, poll, epoll, and kqueue to efficiently handle thousands of concurrent client connections.
I/O multiplexingReactor Patternbackend architecture
0 likes · 12 min read
