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 explains how PHP can handle high‑concurrency tasks by encapsulating functionality into independent units, demonstrating practical examples of multi‑process, multi‑thread, and coroutine approaches using the pcntl, pthread, and Swoole extensions to boost performance and resource management.
This article explains Nginx's event‑driven architecture, asynchronous non‑blocking I/O, and master‑worker multi‑process model, showing how these techniques eliminate waiting, maximize resource utilization, and enable the server to handle massive concurrent connections efficiently.
This article details how Xigua Video analyzed and optimized the startup of multiple Android subprocesses—including push, mini‑app, sandboxed, and exec processes—by applying on‑demand loading, SDK integration, and monitoring techniques, resulting in measurable performance and quality improvements.
The article explains how the UBC SDK’s log‑center deduplication suffers from package and log duplication, identifies three root causes—database corruption, WAL write failures, and multi‑process conflicts—and presents concrete fixes that reduced duplicate rates from 0.3 % to under 0.1 %.
This article explains how to implement encapsulated concurrent programming in PHP by using the pcntl extension for multi‑processes, the pthread extension for multi‑threads, and the Swoole extension for coroutines, providing clear code examples and discussing the advantages of each approach.
The paper presents a high‑performance Android code‑coverage solution that uses standard reflection to read the ClassLoader’s ClassTable, achieving over five‑times faster collection than existing tools while remaining stable, compatible, multi‑process capable, and enabling incremental, cloud‑based reporting for reducing app size.
Chromium evolved from a single‑process browser to a service‑oriented, multi‑process architecture—separating Browser, Renderer, GPU, Network, Storage, and other services into isolated processes and threads—to improve stability, performance, and security while allowing configurable trade‑offs for memory‑constrained devices such as Android WebView.
Chrome separates browsing tasks into distinct browser, renderer, plugin, and GPU processes, parses HTML/CSS into DOM, layout, paint, and compositing trees, rasterizes tiles on a compositing thread, and uses the GPU process to display frames, enabling optimized, smooth animations such as danmaku while balancing memory usage and security.
This article provides a comprehensive guide to PHP multi‑process development on Linux, covering basic shell commands, ELF file types, terminal concepts, process states, orphan and zombie processes, process groups and sessions, signal handling, and practical pcntl/posix code examples for forking, daemonizing, and managing child processes.
This article explains Nginx's network design, showing how the master process only creates and binds listening sockets while worker processes each create an epoll instance, register events, and handle accept, read, and write operations, illustrating the complete flow from code snippets to multi‑process coordination.
The article dissects Android WebView’s evolution to Chromium‑based multi‑process mode, explains the costly initialization steps—including thread checks, provider creation, and Chromium engine startup in a sandbox process—highlights common security pitfalls, and offers idle‑time pre‑initialization and request‑interception techniques to boost performance.
This article explains Nginx's network design, detailing how the master process only creates and binds listening sockets while multiple worker processes each create their own epoll instance, register events, and handle client connections through accept, connection initialization, and event‑driven I/O.
This article explains how Nginx separates network responsibilities between its master and worker processes, detailing the creation of listening sockets, the use of epoll for event‑driven I/O, the initialization of modules, and the handling of client connections in a multi‑process environment.
This article explains Nginx's multi‑process design, detailing how the master process handles socket binding and listening while each worker creates its own epoll instance, registers events, and processes connections through a well‑structured event loop with code examples from the source tree.
This article explains how a SaaS client for enterprise customers tackled stability, security, and latency challenges on low‑end PCs by redesigning its architecture, introducing proactive resource monitoring, multi‑process isolation, and a plug‑in system to enable scalable, customizable performance improvements.
This article explains how Nohost extends the Whistle packet‑capture tool into a multi‑process, multi‑user remote proxy platform, detailing its architecture, interaction flow, master‑process logic, environment injection, user‑state recording, and Whistle process management for developers and operations teams.
This article walks through the rapid development of a PC client for the Wenku platform using Electron, covering technology selection, framework fundamentals, multi‑process architecture, Chromium‑Node integration, practical implementation details such as window management, code injection for fast iteration, and debugging versus release workflows.
This article explains how to build a non‑intrusive debugging and diagnostic platform for Node.js, covering process and thread inspection using the V8 Inspector API, dynamic control via an SDK, multi‑process and multi‑thread handling with Agent processes, and practical usage steps.
This article dives deep into WKWebView on iOS/macOS, explaining its network architecture, cookie handling, multi‑process model, and the four major production issues—request proxy, cookie management, full‑screen adaptation, and WebContent crashes—while offering detailed, source‑level solutions and implementation tips.
This tutorial walks iOS developers through downloading the WebKit source, configuring and compiling it, setting up a debugging project or using the MobileMiniBrowser demo, and analyzing WKWebView’s multi‑process architecture—including UI, WebContent, Network, and Storage processes—to troubleshoot and profile rendering behavior.
This article explains how Node.js handles processes, demonstrates creating child processes with fork, illustrates inter‑process communication (IPC) using send and message events, explores handle passing and shared ports, and shows how to build robust clusters with the built‑in cluster module.
This article analyzes the limitations of native Twemproxy, describes how Nginx's master‑worker multi‑process model and related Linux kernel features were integrated to create a high‑performance, highly available cache proxy, and presents extensive online and benchmark results showing significant latency and QPS improvements.
This comprehensive guide explains the fundamentals of processes and threads, demonstrates practical Node.js demos for single‑threaded and multi‑threaded scenarios, and walks through creating child processes, multi‑process architectures, and daemon services, providing clear code examples and performance insights for backend developers.
The project re‑engineers Twemproxy by adopting Nginx’s master‑worker multi‑process model, adding non‑blocking accept locks, reuseport load balancing, CPU affinity and crash isolation, which transforms the single‑threaded proxy into a scalable, low‑latency, high‑QPS solution suitable for public‑cloud high‑concurrency workloads.
This multi‑part article explains Chrome’s low‑level architecture—from CPU/GPU fundamentals and its multi‑process model to the step‑by‑step navigation flow, the rendering pipeline, and how the compositor processes input events—providing developers with a deep understanding of browser performance and best‑practice optimizations.
This article details Meitu's engineering of a Redis/Memcached proxy platform, describing why twemproxy was chosen, the limitations of its upstream version, the multi‑process redesign with live configuration reload, added latency metrics, reuse‑port handling, Redis master‑slave support, performance testing, and remaining challenges.
The article details Meitu's adaptation of Twitter's twemproxy into a multi‑process, hot‑reloading, high‑availability Redis/Memcached proxy, describing its architecture, custom features, performance testing, remaining challenges, and open‑source resources for other engineering teams.
This article explains MMKV's design, the challenges of adding multi‑process support on Android, the IPC architecture choices, file‑lock synchronization mechanisms, and performance comparisons with SharedPreferences and SQLite.
This article explains how Node.js uses the Cluster module to create a master‑worker multi‑process architecture, detailing worker creation, inter‑process communication via socketpair, handling of shared ports, and provides practical code examples for master, slave, and low‑level libuv interactions.
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 details the step‑by‑step evolution of the English Fluency Android app’s architecture, covering its early broadcast‑based design, the adoption of a plugin‑based modular core, multi‑process integration, auxiliary systems such as asynchronous loading, event bus, monitoring, and support components for file storage, DNS protection, image loading, and downloading.
This article details a step‑by‑step approach for transforming a modern Android phone application into a tablet‑optimized version within three months, covering UI redesign, activity‑to‑fragment conversion, multi‑process handling, task management, and practical code snippets for a robust Pad‑ification architecture.
Learn how to achieve comprehensive code coverage for multi‑process Node.js applications by using Istanbul, instrumenting child processes, writing Mocha tests, and merging coverage reports, with detailed examples of master‑worker RPC, custom fork hacks, and package.json scripts for automated testing.
This article explains how to build a robust multi‑process Node.js server using the cluster module, covering round‑robin load balancing, graceful worker shutdown, process monitoring, and inter‑process communication with code examples for both master and worker processes.
This article examines Node.js’s early criticisms about reliability and single‑threaded limits, then explains how the built‑in cluster module and fork() enable multi‑process deployment, load balancing, and communication, illustrated with code demos, performance insights, and a look at nginx proxy integration.
