1 views collected around this technical thread.
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.
The article analyzes why relying solely on operating‑system threads cannot easily achieve single‑machine million‑level concurrency, examining thread stack memory misconceptions, kernel‑level context‑switch costs, and how user‑space coroutine scheduling overcomes these limits.
This article explains Redis's single‑threaded network model, the role of IO multiplexing, the multithreading features introduced in Redis 6.0, and how to configure IO threads to improve throughput and latency.
Socket provides a file‑descriptor based network communication abstraction in the OS, while epoll uses a red‑black‑tree and ready‑queue mechanism to deliver O(log N) scalable I/O event handling, together forming the core design that enables high‑concurrency servers to efficiently manage thousands of connections.
This article explains Netty's powerful asynchronous architecture, compares classic multithread, Reactor, select, poll, and epoll I/O multiplexing models, demonstrates JNI integration for native performance, and provides complete example code for building a high‑performance epoll‑based server in Java.
This article explains Netty’s asynchronous architecture, compares classic multithread, Reactor, select, poll and epoll models, clarifies level‑triggered versus edge‑triggered event handling, and provides step‑by‑step JNI and hand‑written epoll server examples in C to illustrate high‑performance backend development.
This article explains the Linux poll() system call, detailing its pollfd structure, event flags, parameters like nfds and timeout, return values, and step‑by‑step operation flow for reading and writing data, highlighting differences from select and its advantages on 32‑bit systems.
This article explains how Redis operates primarily with a single‑threaded model for memory and network operations, why this design is efficient, and how recent versions introduce multi‑threaded components for network I/O, persistence, and asynchronous deletion while preserving thread safety.
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.
The article explains that Java database connection pools rely on blocking I/O and JDBC design rather than IO multiplexing, detailing the technical, architectural, and ecosystem reasons why multiplexed DB access is uncommon despite its potential performance benefits.
This article explains Netty’s reactor‑based asynchronous architecture, compares classic multithread, select, poll and epoll I/O multiplexing models, demonstrates Java‑C interaction via JNI, and provides a complete hand‑written epoll server implementation with detailed code and performance insights.
The article explains that database connection pools remain based on blocking I/O because JDBC was designed for BIO, managing session state per connection, and the ecosystem lacks a unified non‑blocking driver, making IO multiplexing technically possible but practically complex and rarely needed.
Although IO multiplexing can improve performance, Java applications typically use traditional connection pools like c3p0 or Tomcat because JDBC is built on blocking I/O, DB sessions require separate connections, and integrating NIO would complicate program architecture, making connection pools the pragmatic, mature solution.
This article introduces the basic concepts of I/O and explains three Unix network programming models—blocking I/O, non‑blocking I/O, and I/O multiplexing—detailing their workflows, advantages, disadvantages, and practical analogies for better comprehension.
The article explains why Java applications typically use traditional database connection pools instead of IO multiplexing, covering JDBC’s blocking design, session management, ecosystem maturity, and the complexity of integrating non‑blocking I/O with existing frameworks, while noting that a non‑blocking implementation is technically feasible.
This article explains Netty's high‑performance asynchronous architecture, compares classic multithread, Reactor, select, poll and epoll I/O multiplexing models, describes level‑triggered versus edge‑triggered event handling, and provides a step‑by‑step JNI example and a hand‑written epoll server implementation in C.
This article explains how Netty implements a powerful asynchronous, event‑driven architecture using the Reactor pattern, compares classic multithread, select, poll and epoll I/O multiplexing models, demonstrates JNI integration with Java, and provides a complete, annotated epoll server example with level‑triggered and edge‑triggered handling for high‑concurrency backend development.
This article explains Netty’s reactor‑based asynchronous architecture, compares classic multithread, select, poll and epoll models, demonstrates JNI integration with C code, and provides a complete hand‑written epoll server example to illustrate high‑performance backend networking in Java.
This article explains Netty’s high‑performance asynchronous architecture, the evolution of I/O multiplexing models from select to poll and epoll, demonstrates Java‑C integration via JNI with detailed code examples, and provides a complete hand‑written epoll server in C for achieving million‑connection concurrency.
This article provides an in‑depth explanation of Linux I/O multiplexing models—including select, poll, and epoll—detailing their mechanisms, advantages, limitations, and practical C code examples, while also covering edge‑triggered vs level‑triggered behavior and offering a complete epoll server implementation.