This article explains Nginx's multi‑process, event‑driven design, its master‑worker model, modular architecture, I/O multiplexing mechanisms such as epoll, and how these factors together enable the server to achieve high performance and support massive concurrent connections.
This article explains Nginx’s multi‑process architecture, event‑driven model, module system, HTTP connection workflow, and I/O multiplexing mechanisms such as select, poll, and epoll, illustrating why the server achieves high performance and scalability.
This article explains Nginx's high performance by detailing its multi‑process architecture, asynchronous event‑driven I/O, request handling flow, module types, comparison with Apache, maximum connection calculations, HTTP request/response structure, and the differences among select, poll, and epoll.
This article explains Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, HTTP connection handling, modular design, and I/O mechanisms, comparing it with Apache, and clarifying common questions about worker processes, maximum connections, and concurrency.
Netty, a Java‑based asynchronous event‑driven framework created in 2008, offers a unified API for multiple transports, a powerful reactor thread model, built‑in codecs, extensive protocol support, high throughput, low latency, robust error handling, and a vibrant ecosystem adopted by major tech companies and open‑source projects.
This article explains how to combine RocketMQ with Knative to create cloud‑native, event‑driven serverless applications, covering cloud‑native fundamentals, Knative architecture, RocketMQSource integration, a food‑delivery use case, deployment steps, command‑line examples, and additional scenarios.
This article explains the design of event‑driven architectures for high‑performance web services, compares the Reactor (synchronous) and Proactor (asynchronous) models, and provides Java‑style pseudocode for their core components, handlers, and event loops.
This article explores Nginx’s high performance by dissecting its multi‑process architecture, event‑driven model, modular design, and I/O handling, comparing it with Apache, and explaining connection limits, request flow, and concurrency mechanisms to reveal why Nginx excels under heavy load.
This article explains Nginx’s highly modular design, its core, optional and third‑party modules, the multi‑process and asynchronous non‑blocking request handling, the event‑driven model, and the master‑worker interaction that together enable efficient, scalable web server performance.
The article explains how microservices communicate via RPC or event‑driven approaches, analyzes different coupling types, compares event notification and event sourcing, discusses API‑gateway and service composition, and offers practical guidance on limiting microservice count and using internal microservice design.
This article explains the principles of event‑driven programming, compares traditional linear execution with event‑driven models, and details various I/O models—including blocking, non‑blocking, multiplexing, signal‑driven, and asynchronous—providing Python code examples and discussing their advantages and use cases.
This article explains why Nginx delivers high performance and concurrency, covering its multi‑process architecture, master‑worker model, event‑driven I/O (select, poll, epoll), module system, HTTP request handling, and comparison with Apache, while providing practical insights into configuration and scalability.
This article explains the fundamentals of serverless computing, distinguishes between Function as a Service (FaaS) and Backend as a Service (BaaS), describes how the model works, outlines ideal use cases, and discusses its limitations such as cold starts, vendor lock‑in, debugging difficulties, and configuration complexity.
This article explains Nginx’s multi‑process model, detailing the roles of master and worker processes, the HTTP connection lifecycle, event‑driven architecture, module types, and performance comparisons with Apache, while also covering I/O models like select, poll, and epoll.
To generate a user‑enriched order report in a microservice system, the article compares four approaches—direct DB access, REST data aggregation, batch pulling, and an event‑driven model—highlighting their trade‑offs in coupling, performance, scalability, and resilience, and recommends the event‑push solution.
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.
This tutorial explains how to create an Alibaba Cloud Kafka instance, configure topics and consumer groups, deploy the Knative Kafka addon, define a Knative Service and KafkaSource, and verify message delivery using CloudEvents, enabling serverless event‑driven applications.
This article explores Nginx’s elegant architecture, detailing its master‑worker process model, modular design, event‑driven engine, and the step‑by‑step initialization sequence—including command‑line parsing, cycle creation, container setup, configuration parsing, socket inheritance, and listening socket creation—based on version 1.15.8.1.
This article explains the concept, evolution, architecture, advantages, disadvantages, and typical use cases of Serverless computing, highlighting its rapid growth, event‑driven model, and relevance for front‑end developers seeking to focus on business logic without managing underlying infrastructure.
The article explains what Serverless (or Function as a Service) is, outlines its technical characteristics, business benefits, and ideal application scenarios, and argues that Serverless represents a fundamental shift toward cloud‑native architectures in modern software development.
This article introduces Node.js by covering its origins, core architecture, key features such as event‑driven non‑blocking I/O, and the scenarios where it excels, helping readers decide when and why to choose Node.js for backend development.
The article analyzes the rapid growth of the serverless market, outlines the technical limitations of existing serverless solutions, and details Tencent Cloud's Serverless 2.0 architecture—including event functions, HTTP functions, HTTP services, developer tools, DevOps integration, and monitoring—while presenting real‑world use cases and performance improvements.
This article explains the two main network I/O architectures—thread‑based designs such as one‑connection‑per‑thread, pre‑forked processes, and their pros and cons, as well as event‑driven designs like the Reactor pattern, thread pools, and multiple reactors—helping readers choose the appropriate model for different server workloads.
This article explains how Spring Cloud Stream leverages Spring Messaging and Spring Integration to create highly scalable, event‑driven microservices, covering core concepts, message channels, binders, code examples, and the underlying processing flow for both producers and consumers.
This article provides a comprehensive overview of Nginx, covering its high‑performance features, modular architecture, proxy capabilities, event‑driven model, multi‑process and asynchronous processing mechanisms, and how these components work together to deliver scalable web services.
This article explains Nginx’s core modules—process, event, and network—detailing how the master‑worker architecture, daemon mode, and asynchronous non‑blocking event handling enable efficient CPU utilization and high concurrency for modern web servers.
This article introduces serverless architecture and Tencent Cloud's SCF, explains how function‑as‑a‑service abstracts servers with pay‑per‑use, automatic scaling and trigger‑driven execution, and showcases typical scenarios such as API services, object processing, log analysis, message handling, and scheduled jobs.
This article explains why manufacturing firms need cross‑level real‑time performance metrics, outlines key enterprise roles, presents reference architectures for system integration, MES functions, event‑driven mechanisms, communication protocols, and data collection and aggregation components.
Fibonacci is JD.com's enterprise-grade serverless function platform combining container technology, serverless architecture, and event-driven mechanisms to provide high-availability, high-efficiency, and high-usability FaaS solutions.
This article analyzes the shortcomings of existing iOS remote‑control solutions, examines event‑driven and screen‑capture technologies, and presents a practical implementation that combines private APIs, optimized screenshot compression, and socket‑based real‑time streaming to achieve millisecond‑level event response and high‑frame‑rate video for multi‑device iOS control.
The article explains how Nginx achieves high concurrency, performance, and efficiency through its master‑worker process model, modular design, event‑driven non‑blocking architecture, and built‑in proxy capabilities, making it a leading web server for reverse proxy and load balancing.
This article compares Nginx and Apache, explains Apache's three processing models, details how Nginx achieves superior high‑concurrency performance through event‑driven, single‑threaded architecture and efficient memory usage, and outlines key techniques for building scalable web servers.
The article explains how traditional microservice architectures evolve into event‑driven reactive microsystems by adopting events‑first DDD, reactive design, and event‑based persistence, highlighting the role of the Actor model, asynchronous non‑blocking communication, event sourcing, and saga‑based distributed transaction handling.
This article explains Nginx’s modular architecture, core, standard and optional HTTP modules, mail service and third‑party extensions, then details its multi‑process and asynchronous non‑blocking request handling, event‑driven model, master‑worker design, and inter‑process communication, providing a solid foundation for deeper source‑code study.
This article explains Nginx’s modular architecture, detailing core, HTTP, mail and third‑party modules, its multi‑process and asynchronous non‑blocking request handling, the event‑driven model with I/O multiplexing, and the master‑worker process interaction that together enable high‑performance web serving.
This article introduces Netty, an asynchronous event‑driven network framework, covering its design goals, performance benefits, core components such as zero‑copy and unified APIs, advanced features like SSL/TLS and WebSocket support, and explains its single‑thread, multi‑thread, and master‑slave thread models for high‑concurrency backend development.
The article recaps a technical talk by Qunar’s accommodation trading system lead, covering event‑driven design, flexible document schemas, and reliability techniques such as circuit breaking, gray releases, and automated testing to improve scalability and maintainability of backend transaction platforms.
The article explains how a transaction system evolved from a monolithic application to a service‑oriented design, tackling issues such as RPC‑induced coupling, state explosion, and distributed consistency by introducing reliable event‑driven mechanisms, a core StoreEngine, and an ActorEngine framework.
These notes distill Mark Richards' O'Reilly guide on software architecture patterns, explaining layered, event‑driven (mediator and broker), microkernel, microservices, and space‑based architectures, their key concepts, examples, trade‑offs, and evaluation criteria to help developers select the most suitable pattern for their projects.
This article explains how StreamSQL runs on the Slipstream engine in event‑driven mode, shows how to enable the mode, and provides step‑by‑step code examples for low‑latency stream processing, window aggregation, and joining multiple window streams.
The article outlines the core components of Netty—Bootstrap/ServerBootstrap, EventLoop, EventLoopGroup, ChannelPipeline, Channel, Future/ChannelFuture, ChannelInitializer, and ChannelHandler (Inbound and Outbound)—explaining their roles in configuring, handling I/O, and processing data within a non‑blocking, event‑driven network application.
The article dissects Redis’s architecture by examining its single‑threaded reactor network model, core data structures and memory‑management tactics, AOF/RDB persistence mechanisms, and master‑slave, Sentinel, and Cluster multi‑node strategies, highlighting how each design choice balances speed, memory usage, and system complexity.
This article recounts Zhihu's evolution from a two‑person startup to a platform serving over 80 million monthly users, detailing early Python/Tornado choices, high‑availability, custom logging, event‑driven design, rendering optimizations, and the transition to a service‑oriented architecture.
This article presents the event‑driven architecture of a hotel order transaction system, outlines common challenges such as QMQ configuration, exception handling, and coupling, and introduces an Actor‑based solution that provides decoupling, customizable retry, fault‑recovery, and detailed monitoring for over twenty business services.
This article explains the Function-as-a-Service (FaaS) model, illustrates how AWS Lambda can replace traditional server‑centric image upload workflows by handling scaling, storage, and database updates through event‑driven functions, and discusses the broader impact of serverless on cloud architecture.
This article explains the differences between synchronous and asynchronous I/O, clarifies blocking versus non‑blocking calls, and describes various I/O models—including blocking, non‑blocking, multiplexed, event‑driven, and asynchronous—illustrated with diagrams to help readers understand how the kernel and user processes interact during I/O operations.
NGINX achieves top‑tier performance and scalability through a multi‑process architecture that limits worker processes to one per CPU core, employs single‑threaded non‑blocking workers handling many connections via an event‑driven state machine, and isolates privileged tasks in a master process.
Backend DevelopmentWeb Server Architectureevent-driven
This article describes how to redesign a Java‑based message bus by integrating Guava EventBus to streamline broadcast notifications and replace the traditional chain‑of‑responsibility pattern with an event‑driven approach, providing code examples and deployment considerations.
This article explains how most Android code is driven by event callbacks, examines single‑event and multi‑event implementations, discusses the pitfalls of bloated callbacks, and offers practical strategies to structure and simplify callback‑heavy code for clearer, more maintainable apps.
This article explains nginx’s high‑performance architecture, detailing its daemon mode with a master process and multiple worker processes, the multi‑process model advantages, signal‑based control, the asynchronous non‑blocking event handling using epoll, and includes a representative pseudo‑code of its event loop.
This article explains how Nginx achieves high concurrency and performance through its master‑worker process model, event‑driven state machine, non‑blocking I/O, and graceful configuration reloads, contrasting it with traditional blocking multi‑process web servers.
This article explains why high‑concurrency design is essential for modern internet services, compares vertical (scale‑up) and horizontal (scale‑out) scaling, revisits the C10K/C10M challenges, and reviews process, thread, coroutine, and event‑driven models to help engineers build ultra‑scalable web servers.
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.
This article recounts Zhihu's evolution from a tiny Python‑Tornado service on a single Linode to a massive, highly available backend employing custom logging, event‑driven processing, page‑render optimizations, and a service‑oriented architecture that now supports over 100 million users.
This article introduces Node.js’s core characteristics—event‑driven, non‑blocking I/O, lightweight and efficient—while posing key questions about its underlying mechanisms, asynchronous callbacks, synchronous alternatives, event handling, performance limits, and scenarios where Node.js may not be suitable.
This article traces Node.js’s evolution from a modest 2009 V8‑based runtime to a dominant backend platform, highlighting npm’s impact, its event‑driven, non‑blocking architecture, real‑world strengths and limitations, and why careful evaluation is essential before adopting it.
NGINX achieves high performance and scalability by using a multi‑process architecture with a single master process, multiple single‑threaded non‑blocking worker processes, and dedicated cache loader/manager processes, limiting worker count per CPU core and handling many connections via an event‑driven state machine.
Backend DevelopmentWeb Server Architectureevent-driven
This article explains the evolution of Linux init systems, focusing on Upstart's event‑driven design, core concepts such as jobs and events, configuration syntax, and practical commands for developers and administrators, highlighting its advantages over traditional SysVinit.
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 examines various network server architectures—from blocking sockets and multithreaded designs to select‑based and libev‑driven event loops—highlighting their trade‑offs, performance implications, and practical implementation details for building efficient high‑concurrency services.