The article explains how Nginx sustains one million simultaneous connections by using asynchronous non‑blocking I/O, a robust multi‑process architecture, zero‑copy file transmission, and optimized caching strategies, with concrete configuration examples and performance reasoning.
This article provides a comprehensive, step‑by‑step analysis of Linux's io_uring, covering its architecture, design principles, workflow, performance advantages over traditional models like epoll, practical C code examples, optimization techniques, real‑world use cases, and the challenges developers may face when adopting it.
This article traces the evolution from select and poll to epoll and finally io_uring, explains how multishot accept and receive work, compares benchmark results, and provides practical guidance for migrating production servers from epoll‑based event loops to the newer io_uring model.
This comprehensive guide explains why traditional I/O models become bottlenecks in high‑performance computing, introduces the modern io_uring framework with its submission and completion queues, walks through its design goals, core concepts, workflow, performance comparisons, optimization tips, real‑world use cases, and provides complete C examples for practical adoption.
The article explains how Direct Memory Access (DMA) eliminates CPU‑bound data copies, compares traditional I/O with zero‑copy techniques such as mmap and sendfile, and shows how reducing system calls and context switches can double file‑transfer throughput while highlighting the limits of kernel cache for large files.
This article explores the evolution of Linux I/O models—from blocking and non‑blocking to epoll—and introduces io_uring as a high‑performance asynchronous framework that reduces system‑call overhead, eliminates data copies, and unifies network and disk I/O for modern high‑concurrency applications.
This article traces the evolution of Linux I/O from blocking and non‑blocking models through epoll to the modern io_uring framework, explains its design goals, core concepts, system‑call workflow, and provides practical code examples and performance comparisons for high‑concurrency network and storage applications.
This comprehensive guide explores how coroutines provide a lightweight, lock‑free alternative to traditional threads for high‑concurrency C/C++ server programming, covering their fundamentals, differences from threads, implementation techniques, context switching, scheduler design, epoll integration, timer management, and performance testing.
This article explains Nginx's core Master‑Worker process model, high‑performance event‑driven design, I/O multiplexing with epoll, and asynchronous non‑blocking I/O, showing how these techniques enable the server to sustain millions of simultaneous connections.
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.
This article explains the IOCP (I/O Completion Port) mechanism in Windows, covering its principles, advantages, core components, workflow, practical usage steps with code examples, comparisons to other asynchronous models, and common pitfalls such as thread synchronization, memory management, error handling, and load balancing.
This article explains the fundamental concepts of I/O models—including blocking, non‑blocking, multiplexing and asynchronous approaches—detailing their mechanisms, advantages, drawbacks, code examples in Python, and practical optimization strategies for high‑concurrency backend systems.
This article explains how Nginx achieves high concurrency through its event‑driven architecture, asynchronous non‑blocking I/O, epoll‑based I/O multiplexing, and practical caching configurations that dramatically reduce memory usage and improve response speed in high‑traffic scenarios.
This article explains the distinction between user space and kernel space, describes blocking and non‑blocking I/O, and compares select, poll, and epoll multiplexing techniques, including signal‑driven and asynchronous I/O models with code examples.
This article explains how Nginx’s event‑driven, asynchronous non‑blocking architecture, combined with epoll/kqueue I/O multiplexing and cache optimization, enables it to serve millions of simultaneous connections with high concurrency, low latency, and high throughput.
This article explains how Nginx uses an event‑driven, asynchronous non‑blocking I/O model together with epoll/kqueue and various optimization strategies such as keep‑alive, caching, efficient data structures and load balancing to handle millions of concurrent connections in large‑scale internet architectures.
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.
This article explains Swoole, a C extension for PHP that adds asynchronous I/O, multi‑process and coroutine support, outlines its advantages over traditional PHP, and provides a step‑by‑step guide with code to build a basic high‑performance HTTP server.
This article examines traditional file transfer methods, highlights their performance drawbacks caused by excessive context switches and memory copies, and explains how zero‑copy, PageCache, asynchronous I/O, and direct I/O can dramatically improve throughput and reduce CPU usage in backend systems.
File transfer can be dramatically accelerated by reducing context switches and memory copies, using techniques such as zero‑copy, leveraging PageCache, and employing asynchronous or direct I/O, which together cut system calls, lower CPU usage, and improve concurrency for large‑scale data delivery.
This article examines Node.js’s strengths and weaknesses, its event‑driven architecture, practical code examples, middleware usage, impact on front‑end development, and forecasts its role in future trends such as cloud‑native, serverless, IoT, and AI applications.
Node.js is a server‑side JavaScript runtime built on V8 that replaces the browser environment with native libraries, uses libuv’s event loop and thread pool to provide non‑blocking asynchronous I/O, and organizes its architecture into application code, V8, bindings, and libuv layers for efficient backend development.
This article explains why simple serial file reads are slow, compares multithreaded and event‑loop based approaches, introduces the Reactor pattern and callbacks, and finally shows how coroutines provide a synchronous‑style solution for efficient, non‑blocking I/O processing.
The article analyses a real‑world Node.js service outage caused by sudden 504 timeouts, explains how the asynchronous I/O model creates time‑slice contention under high QPS, presents load‑testing code and results for both I/O‑ and CPU‑bound requests, and offers practical mitigation strategies such as clustering, caching and resource scaling.
libuv is a cross‑platform asynchronous I/O library originally built for Node.js that abstracts event‑driven I/O via handles and requests, provides a single‑threaded event loop with platform‑specific poll mechanisms, and uses a global thread pool for file and DNS operations, all while maintaining a consistent execution model.
libtask, a lightweight coroutine library written by Russ Cox, demonstrates how to build a cooperative multitasking scheduler in C, detailing task creation, context switching, epoll‑based I/O handling, and a non‑preemptive FIFO scheduling model that enables asynchronous I/O to appear synchronous for server development.
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 provides a deep technical walkthrough of libuv’s Linux implementation, covering epoll‑based I/O handling, level‑ and edge‑triggered events, the event‑loop architecture, timer management with a min‑heap, thread‑pool integration, and the mechanisms that drive asynchronous callbacks in Node.js.
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.
This article explains Nginx's high‑performance architecture, covering its daemon mode with master and worker processes, the thundering‑herd problem, advantages of process‑based concurrency, asynchronous non‑blocking I/O, connection handling, keep‑alive and pipeline techniques, as well as key internal data structures such as arrays, queues, lists, strings, memory pools, hash tables, and red‑black trees.
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.
The article explains that JavaScript’s single‑threaded language model relies on the engine and runtime to provide asynchronous I/O and an event loop for concurrency, while multi‑core utilization is achieved through workers, child processes, or clusters, and synchronous APIs remain useful for short, predictable tasks.
This article explains the design concepts, programming practices, performance optimizations, and real‑world applications of iQIYI's open‑source network coroutine library libfiber, covering non‑blocking I/O, coroutine scheduling, event‑engine design, synchronization mechanisms, and its use in high‑performance CDN and DNS services.
This article provides an in‑depth tutorial on Java NIO, covering its fundamentals, IO models (BIO, NIO, AIO), core components such as Channel, Buffer and Selector, detailed code examples for a server and client, and a summary of best practices and limitations.
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.
This article explains Netty as an asynchronous event‑driven network framework, compares synchronous and asynchronous processing, describes event‑driven programming, details the differences among BIO, NIO and AIO I/O models, and outlines Netty's core components and architecture.
This article explains the fundamentals of Swoole coroutines, how they differ from threads and processes, the relationship between coroutines and asynchronous I/O, and provides practical code examples for timers, tasks, and concurrent DNS queries to help PHP developers write efficient, non‑blocking backend applications.
This article explains the evolution of Unix network I/O models, detailing data transmission paths, blocking and non‑blocking operations, and comparing five models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—while clarifying key terminology such as user space, kernel, and file descriptors.
This article explains the four main I/O models—blocking, non‑blocking, I/O multiplexing (select/epoll), and asynchronous I/O—in the context of Linux network programming, clarifying their mechanisms, differences, and when each model is appropriate.
This article dives deep into Node.js internals, explaining why the runtime is both single‑threaded and multi‑threaded, how the event loop, libuv thread pool, epoll/kqueue, and worker_threads collaborate to deliver non‑blocking I/O and efficient concurrency.
This article explains Python's asyncio module, presents a practical HTTP keep-alive benchmark tool built with async I/O, details test setup and performance results, and summarizes key asyncio concepts such as event loops, futures, coroutines, and generators.
This article explains the five Linux I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—and shows how Java's BIO, NIO, and AIO APIs map to these models, using clear analogies and code examples to illustrate their synchronous and asynchronous behaviors.
This article provides a comprehensive guide to Java I/O, explaining the distinction between byte and character streams, the role of abstract and concrete stream classes, how the Decorator pattern extends functionality, the enhancements introduced in NIO.2, and the use of asynchronous I/O with Futures and Callbacks.
This article explains the concept of asynchronous I/O, introduces Python’s provisional asyncio module, and walks through a complete example that creates an HTTP keep‑alive benchmark tool, including code, test environment, performance results, and key asyncio concepts such as event loops, futures, coroutines, and generators.
ScyllaDB, a Cassandra‑compatible NoSQL database, achieves over tenfold performance improvements through a thread‑per‑core design, asynchronous I/O, custom caching, self‑tuning schedulers, a user‑space TCP/IP stack, and LLVM‑JIT query execution, making it a compelling study for high‑performance database engineering.
The article explains the five essential OS I/O models—blocking, non‑blocking, I/O multiplexing, signal‑driven, and asynchronous—illustrates their advantages and drawbacks, and shows how these models underpin modern high‑performance runtimes such as Java NIO2 and Node.js.
This article presents a comprehensive technical case study of Qunar's Order Center, describing its initial architecture, the challenges faced with scaling and reliability, and the successive redesigns in versions 2.0 and 3.0 that introduced Elasticsearch, asynchronous I/O, micro‑service decomposition, rate‑limiting, and a configurable adapter layer to support massive, multi‑line order processing.
This article explains the concept of streams in Unix and Node.js, describes the four stream types, shows how to create and control readable streams with code examples, and demonstrates practical uses such as file serving, piping, and building an HTTP proxy.
This article explains Linux asynchronous I/O (AIO), compares it with synchronous and non‑blocking I/O models, describes the underlying aiocb structure, and provides detailed examples of the AIO API functions such as aio_read, aio_write, aio_error, aio_return, aio_suspend, aio_cancel and lio_listio.
This article explains how to use Nginx rewrite rules to block Internet Explorer and provides a detailed overview of four theoretical I/O models and five practical I/O models used in network services, illustrated with diagrams and a discussion of libevent implementation.
This article explains the four theoretical I/O models—blocking, non‑blocking, synchronous, and asynchronous—and details five practical network service I/O patterns, illustrating each with diagrams and showing how they can be implemented using libraries such as libevent.
This article explains practical techniques for reducing Linux file fragmentation and dramatically improving I/O throughput—ranging from kernel cache tuning and minimum allocation tweaks to asynchronous I/O, read‑ahead, delayed allocation, and even building a custom filesystem that can deliver three to five times faster disk performance.
