BestHub
Sign in
Tagged articles

event loop

118 articles · Page 1 of 2
Cloud Architecture
Cloud Architecture
Jun 23, 2026 · Databases

Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design

Redis sustains millions of concurrent operations not merely because it is single‑threaded, but thanks to its non‑blocking event‑loop I/O, compact in‑memory data structures, serialized command execution that eliminates lock contention, and robust production features such as replication, sharding, persistence, observability and governance.

ClusterLua ScriptingMemory Optimization
0 likes · 40 min read
Why Redis Handles Millions of Concurrent Requests: Event Loop and Cluster Design
Open Source Tech Hub
Open Source Tech Hub
Jun 15, 2026 · Backend Development

Enable Event‑Loop in High‑Performance PHP Framework Webman via CLI

This article demonstrates a concise method to empower Webman command modules with event‑loop capabilities by extending the Worker class, creating an AbstractCommand base, and defining a concrete command that runs within the event‑loop, complete with runnable code examples and execution output.

CommandWebmanevent loop
0 likes · 7 min read
Enable Event‑Loop in High‑Performance PHP Framework Webman via CLI
Data STUDIO
Data STUDIO
Feb 10, 2026 · Backend Development

Master Python asyncio: Make Your Code Fly with Asynchronous Programming

This article explains why synchronous Python code blocks on I/O, introduces asyncio’s event loop and coroutine model, and walks through creating and managing tasks, using TaskGroup, handling timeouts, avoiding common pitfalls, and applying best‑practice patterns for high‑performance I/O‑bound programs.

Asynchronous ProgrammingPythonasyncio
0 likes · 20 min read
Master Python asyncio: Make Your Code Fly with Asynchronous Programming
Subtle Storm
Subtle Storm
Jan 17, 2026 · Backend Development

Deep Dive into Python Concurrency: Asyncio Event Loop, Scheduling, and High‑Performance Web Apps

This article dissects Python's asyncio event loop and coroutine scheduling, compares synchronous threading with asynchronous execution through benchmark tests, examines memory usage across models, presents a full async web service implementation with database and cache pools, and offers a decision matrix for choosing the right concurrency model.

Performance TestingPythonasync web
0 likes · 15 min read
Deep Dive into Python Concurrency: Asyncio Event Loop, Scheduling, and High‑Performance Web Apps
Data STUDIO
Data STUDIO
Jan 13, 2026 · Backend Development

Node.js vs Python: The Ultimate 2026 Backend Technology Selection Guide

This article compares Node.js and Python for backend development in 2026, examining their architectures, performance benchmarks, ecosystem strengths, and suitable use-cases, and provides a decision framework to help developers choose the most appropriate technology based on project requirements, team skills, and scalability needs.

Node.jsasyncbackend development
0 likes · 20 min read
Node.js vs Python: The Ultimate 2026 Backend Technology Selection Guide
Liangxu Linux
Liangxu Linux
Nov 4, 2025 · Fundamentals

Why a Single‑Threaded Event Loop Can Beat Multithreading: Exploring Coroutines and the Reactor Pattern

This article walks through serial file reading, thread‑based parallelism, event‑driven asynchronous I/O, callbacks, and finally shows how coroutines combined with an event loop provide a synchronous‑style solution that scales efficiently without the drawbacks of massive threading.

Asynchronous ProgrammingReactor patterncoroutine
0 likes · 13 min read
Why a Single‑Threaded Event Loop Can Beat Multithreading: Exploring Coroutines and the Reactor Pattern
Code Mala Tang
Code Mala Tang
Jul 18, 2025 · Backend Development

Unlock Lightning-Fast Node.js: 8 Proven Backend Performance Hacks

Discover why a sluggish API hurts user retention, SEO, and costs, and learn eight practical Node.js backend optimization techniques—including mastering the event loop, avoiding blocking code, leveraging async/await, offloading heavy tasks, efficient JSON handling, caching strategies, database tuning, clustering, and continuous monitoring—to boost performance and scalability.

Async/AwaitBackend PerformanceMonitoring
0 likes · 8 min read
Unlock Lightning-Fast Node.js: 8 Proven Backend Performance Hacks
Tech Freedom Circle
Tech Freedom Circle
Jul 17, 2025 · Databases

What Happens Under the Hood When a Redis Command Executes? – A Deep Dive into Redis’s Reactor Model

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
What Happens Under the Hood When a Redis Command Executes? – A Deep Dive into Redis’s Reactor Model
JavaScript
JavaScript
Jun 27, 2025 · Frontend Development

How setTimeout(fn, 0) Unblocks the Main Thread and Boosts UI Responsiveness

Using setTimeout(fn, 0) tricks the JavaScript event loop to downgrade heavy tasks to asynchronous callbacks, freeing the main thread for UI rendering and user interactions, and the article explains the underlying mechanics, practical examples, and modern alternatives like requestAnimationFrame, queueMicrotask, and Web Workers.

AsynchronousFrontendJavaScript
0 likes · 10 min read
How setTimeout(fn, 0) Unblocks the Main Thread and Boosts UI Responsiveness
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
May 12, 2025 · Frontend Development

Understanding Browser Rendering, Event Loop, and Techniques to Avoid Page Jank When Adding Massive DOM Elements

This article explains the underlying browser mechanisms that cause page jank when creating millions of DOM elements, analyzes the event loop, rendering pipeline, macro‑ and micro‑tasks, and presents practical solutions such as setTimeout, requestAnimationFrame, MessageChannel, and requestIdleCallback to keep the UI responsive.

BrowserDOMJavaScript
0 likes · 16 min read
Understanding Browser Rendering, Event Loop, and Techniques to Avoid Page Jank When Adding Massive DOM Elements
Xuanwu Backend Tech Stack
Xuanwu Backend Tech Stack
Feb 21, 2025 · Databases

Why Redis’s In-Memory Architecture Beats Disk: Speed, Events, and Data Structures

Redis stores data directly in memory rather than on disk, leveraging microsecond‑level access, a single‑threaded Reactor event loop with I/O multiplexing, optimized data structures like strings, hashes, lists, sets, and a simple text protocol, all of which combine to deliver exceptionally high performance for high‑frequency read/write workloads.

Data StructuresIn-Memory DatabaseRedis
0 likes · 3 min read
Why Redis’s In-Memory Architecture Beats Disk: Speed, Events, and Data Structures
Open Source Tech Hub
Open Source Tech Hub
Jan 18, 2025 · Backend Development

What New Features Does workerman v5 Bring to PHP Coroutines?

The article explains workerman v5’s major updates—including a revolt/event-loop based engine and multi‑implementation coroutine support—while detailing PHP coroutine concepts, practical async export examples, code snippets, and the future challenges of expanding coroutine ecosystems in PHP.

AsynchronousPHPcoroutine
0 likes · 8 min read
What New Features Does workerman v5 Bring to PHP Coroutines?
Test Development Learning Exchange
Test Development Learning Exchange
Dec 28, 2024 · Backend Development

Using asyncio call_soon, call_at, call_later, and call_soon_threadsafe in Python

This article explains how Python's asyncio library schedules callbacks with call_soon, call_at, call_later, and call_soon_threadsafe, providing detailed usage descriptions and multiple example code snippets that demonstrate immediate, absolute‑time, relative‑time, and thread‑safe task scheduling within an event loop.

Thread Safetyasynciocallback-scheduling
0 likes · 6 min read
Using asyncio call_soon, call_at, call_later, and call_soon_threadsafe in Python
php Courses
php Courses
Dec 2, 2024 · Backend Development

Understanding PHP 8.1 Fibers: How They Work and Their Limitations

This article explains PHP 8.1 Fibers, describing their cooperative multitasking mechanism, how suspension and resumption affect the main script, why they do not provide true asynchronous execution, and how they can be combined with event loops for more efficient non‑blocking code in backend development.

AsynchronousFibersPHP
0 likes · 7 min read
Understanding PHP 8.1 Fibers: How They Work and Their Limitations
Architect
Architect
Jul 7, 2024 · Databases

Why Is Redis So Fast? Inside Its Single‑Threaded and Multithreaded Architecture

This article explains how Redis achieves tens of thousands of QPS on average hardware, breaks down the technical reasons behind its speed—including C implementation, in‑memory design, epoll‑based I/O multiplexing, and a single‑threaded event loop—while also detailing the evolution to multithreaded I/O in later versions.

Database ArchitectureRedisevent loop
0 likes · 19 min read
Why Is Redis So Fast? Inside Its Single‑Threaded and Multithreaded Architecture
Open Source Tech Hub
Open Source Tech Hub
May 20, 2024 · Backend Development

Master Asynchronous PHP with AMPHP: Boost Performance and Concurrency

This article explains asynchronous programming concepts for PHP, introduces the lightweight AMPHP library and its coroutine‑based event loop, outlines core technologies, common use cases, installation steps, required PHP version, and provides practical code examples for building non‑blocking, high‑throughput applications.

AmpHPAsynchronous ProgrammingPHP
0 likes · 9 min read
Master Asynchronous PHP with AMPHP: Boost Performance and Concurrency
Baidu Geek Talk
Baidu Geek Talk
Dec 18, 2023 · Frontend Development

Browser Event Loop Mechanism: Complete Guide to Rendering, Performance Optimization and Interaction Metrics

The guide explains the browser’s event‑loop cycle, how macro‑tasks, micro‑tasks, requestAnimationFrame and requestIdleCallback interact with rendering, details long‑task impacts, React’s time‑slicing via MessageChannel, key interaction metrics such as TTI, FID and upcoming INP, and practical optimizations like task splitting, lazy loading and service‑worker caching.

FIDINPReact Time Slicing
0 likes · 19 min read
Browser Event Loop Mechanism: Complete Guide to Rendering, Performance Optimization and Interaction Metrics
Programmer DD
Programmer DD
Dec 7, 2023 · Frontend Development

Why JavaScript Is Essential for Modern Web Development: A Beginner’s Guide

This article introduces JavaScript’s origins, core characteristics, and versatile roles—from front‑end scripting in browsers to server‑side execution with Node.js—while explaining its event‑driven model, variable declarations, DOM interaction, and asynchronous programming features for beginners.

FrontendJavaScriptProgramming Basics
0 likes · 6 min read
Why JavaScript Is Essential for Modern Web Development: A Beginner’s Guide
360 Smart Cloud
360 Smart Cloud
Dec 7, 2023 · Fundamentals

Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development

This article explains how asynchronous programming and event‑driven mechanisms work in both frontend JavaScript and backend Golang, covering the JavaScript event loop, macro‑ and micro‑tasks, goroutine‑based concurrency, and the kernel‑level epoll architecture that together enable efficient, non‑blocking execution.

Asynchronousbackendconcurrency
0 likes · 17 min read
Understanding Asynchronous and Event Mechanisms in Frontend and Backend Development
dbaplus Community
dbaplus Community
Nov 29, 2023 · Backend Development

How Redis Achieves High‑Performance Networking with a Single‑Threaded Event Loop

This article explains how Redis uses Linux epoll and a single‑threaded event loop to handle millions of connections efficiently, covering the creation of the epoll object, server initialization, event registration, the main processing loop, and the mechanisms for reading, writing, and managing pending tasks.

backend developmentepollevent loop
0 likes · 23 min read
How Redis Achieves High‑Performance Networking with a Single‑Threaded Event Loop
Rare Earth Juejin Tech Community
Rare Earth Juejin Tech Community
Nov 24, 2023 · Frontend Development

Understanding JavaScript Event Loop, Microtasks and Macrotasks

This article explains JavaScript’s single‑threaded nature, the event loop mechanism, and the distinction between microtasks and macrotasks, illustrating their execution order with detailed code examples and step‑by‑step analysis to help developers grasp asynchronous behavior in front‑end development.

JavaScriptevent loopfrontend development
0 likes · 7 min read
Understanding JavaScript Event Loop, Microtasks and Macrotasks
ByteFE
ByteFE
Jul 26, 2023 · Frontend Development

Browser Fundamentals: Process Architecture, V8 Engine, Memory Management, Event Loop, Rendering, and Security

This comprehensive guide explains browser fundamentals, covering process and thread architecture, single‑ and multi‑process models, the V8 engine's data types, property ordering, memory allocation and garbage collection, compilation stages, the event loop, rendering pipeline, performance optimization techniques, and security mechanisms.

BrowserRenderingV8
0 likes · 43 min read
Browser Fundamentals: Process Architecture, V8 Engine, Memory Management, Event Loop, Rendering, and Security
ITPUB
ITPUB
Apr 30, 2023 · Databases

Inside Redis: Unveiling Its Core Architecture and Data Storage Mechanics

This article provides a detailed walkthrough of Redis's internal architecture, covering the client module, event‑driven networking, command processing, memory management, persistence strategies, high‑availability features, and the low‑level data structures such as redisServer, redisDb, dict, dictEntry, and redisObject that power its fast key‑value storage.

C languageData StructuresDatabase Internals
0 likes · 12 min read
Inside Redis: Unveiling Its Core Architecture and Data Storage Mechanics
JD Cloud Developers
JD Cloud Developers
Apr 11, 2023 · Fundamentals

Mastering Dart’s Event Loop: From Microtasks to Isolates

This article explains Dart’s single‑threaded event‑loop model, the distinction between microtask and event queues, how to schedule tasks, use Futures, async/await, isolates, and practical patterns like LoadBalancer and CancelableOperation to manage asynchronous operations in Flutter apps.

DARTFutureasync
0 likes · 17 min read
Mastering Dart’s Event Loop: From Microtasks to Isolates
Baidu Geek Talk
Baidu Geek Talk
Dec 21, 2022 · Backend Development

Understanding Node.js: Architecture, Event Loop, and Asynchronous I/O

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.

JavaScriptNode.jsasynchronous I/O
0 likes · 16 min read
Understanding Node.js: Architecture, Event Loop, and Asynchronous I/O
ByteFE
ByteFE
Dec 12, 2022 · Frontend Development

Understanding JavaScript Asynchronous Mechanisms and the Event Loop

This article explains why JavaScript, despite being single‑threaded, needs asynchronous mechanisms such as the event loop, details macro‑ and micro‑tasks, compares browser and Node.js implementations, and demonstrates common pitfalls and best practices using callbacks, Promise, generator, and async/await patterns.

FrontendJavaScriptNode.js
0 likes · 16 min read
Understanding JavaScript Asynchronous Mechanisms and the Event Loop
ByteFE
ByteFE
Nov 8, 2022 · Frontend Development

Understanding the JavaScript Event Loop in Browsers and Node.js

This article explains the fundamentals of JavaScript's event loop, covering browser asynchronous execution, macro‑ and micro‑tasks, timer inaccuracies, view rendering, and the differences in Node.js implementation, while providing code examples to illustrate execution order and practical implications for developers.

BrowserJavaScriptNode.js
0 likes · 18 min read
Understanding the JavaScript Event Loop in Browsers and Node.js
Sohu Tech Products
Sohu Tech Products
Oct 19, 2022 · Fundamentals

Understanding the JavaScript Event Loop in Browsers and Node.js

This article explains the fundamentals of JavaScript's event loop, covering single‑threaded execution, the role of macro‑tasks and micro‑tasks, differences between browser and Node.js implementations, and includes code examples that illustrate task scheduling and execution order.

BrowserJavaScriptNode.js
0 likes · 17 min read
Understanding the JavaScript Event Loop in Browsers and Node.js
Node Underground
Node Underground
Sep 26, 2022 · Backend Development

Mastering Node.js: Architecture, APIs, and the Event Loop Explained

This comprehensive guide explores Node.js’s architecture, core APIs, global variables, built‑in modules, function styles, the event‑loop mechanics, task scheduling, next‑tick and microtasks, libuv’s role, and strategies for off‑loading work, providing developers with a deep understanding of how Node.js runs JavaScript efficiently.

Asynchronous ProgrammingNode.jsbackend development
0 likes · 23 min read
Mastering Node.js: Architecture, APIs, and the Event Loop Explained
ITPUB
ITPUB
Aug 31, 2022 · Databases

How Redis Implements Multithreading: A Deep Dive into Its I/O Thread Model

This article explains Redis's single‑threaded architecture, its limitations, and how Redis 6.0+ adds configurable I/O threads to parallelize read/write handling, detailing the server initialization, event loop, task queues, and the interaction between the main thread and worker threads.

I/O ThreadsRedisServer Architecture
0 likes · 27 min read
How Redis Implements Multithreading: A Deep Dive into Its I/O Thread Model
Python Programming Learning Circle
Python Programming Learning Circle
Aug 20, 2022 · Fundamentals

Understanding Python Asyncio: Core Concepts, Event Loop Mechanics, and Performance Comparison

This article introduces Python's asyncio library, explains the fundamentals of coroutines, tasks, and the event loop, compares synchronous and asynchronous code execution with practical examples, and demonstrates how asynchronous programming can significantly improve performance in I/O‑bound scenarios.

Asynchronous Programmingconcurrencyevent loop
0 likes · 10 min read
Understanding Python Asyncio: Core Concepts, Event Loop Mechanics, and Performance Comparison
Sohu Tech Products
Sohu Tech Products
Jun 8, 2022 · Mobile Development

Understanding iOS RunLoop: Architecture, Modes, and Message Handling

This article provides an in‑depth technical overview of iOS RunLoop, explaining its relationship to threads, event loops, RunLoop modes, sources, timers, observers, and the underlying Mach message mechanisms, while including original source code excerpts for reference.

CoreFoundationMachRunLoop
0 likes · 30 min read
Understanding iOS RunLoop: Architecture, Modes, and Message Handling
ITPUB
ITPUB
Jun 7, 2022 · Backend Development

How Redis Achieves High Performance with a Single‑Threaded Event Loop

This article explains how Redis uses Linux epoll and a single‑threaded event‑driven architecture to handle tens of thousands of connections efficiently, detailing the initialization of the server, the event‑loop mechanics, and the processing of client commands from accept to reply.

Redisepollevent loop
0 likes · 22 min read
How Redis Achieves High Performance with a Single‑Threaded Event Loop
IT Services Circle
IT Services Circle
May 31, 2022 · Fundamentals

Understanding Coroutines, Event Loops, and Asynchronous I/O

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.

CoroutinesReactor patternasynchronous I/O
0 likes · 12 min read
Understanding Coroutines, Event Loops, and Asynchronous I/O
Refining Core Development Skills
Refining Core Development Skills
May 24, 2022 · Backend Development

An In-Depth Analysis of Redis Multi-Threaded Architecture and I/O Event Processing

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.

C programmingI/O multiplexingRedis
0 likes · 21 min read
An In-Depth Analysis of Redis Multi-Threaded Architecture and I/O Event Processing
IT Architects Alliance
IT Architects Alliance
Feb 27, 2022 · Backend Development

Inside Redis: How Its Single‑Threaded Event Loop Works

This article walks through Redis’s annotated source code to explain how its single‑threaded architecture initializes the server, loads configuration and data, and continuously processes file and time events within a while‑loop, revealing why Redis achieves high performance without spawning additional worker threads.

C++Redisbackend development
0 likes · 9 min read
Inside Redis: How Its Single‑Threaded Event Loop Works
Top Architect
Top Architect
Feb 27, 2022 · Backend Development

Analyzing Redis' Single‑Threaded Model and Event Loop from Source Code

This article examines Redis's single‑threaded architecture by walking through its source code, detailing the main function initialization steps, the event‑loop implementation, and how file and time events are processed, while also noting the promotional messages interspersed throughout.

C languageRedisSingle‑threaded
0 likes · 12 min read
Analyzing Redis' Single‑Threaded Model and Event Loop from Source Code
Top Architect
Top Architect
Dec 26, 2021 · Databases

Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations

The article explains how Redis, originally a single‑threaded in‑memory cache, introduces Lazy Free in version 4.0 and multi‑threaded I/O in version 6.0 to mitigate blocking during large key deletions, describes the underlying event‑driven architecture, shows relevant source code, and discusses the benefits and constraints of these mechanisms.

Lazy FreeMultithreaded I/ORedis
0 likes · 16 min read
Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture, Mechanisms, and Limitations
Aotu Lab
Aotu Lab
Nov 11, 2021 · Frontend Development

Why requestAnimationFrame Beats setTimeout: Deep Dive into the Browser Event Loop

requestAnimationFrame lets browsers schedule animation callbacks just before the next repaint, offering smoother 60 Hz updates compared to setTimeout; this article explains its API, demonstrates code examples, explores the event loop, task and microtask queues, rendering timing, cross‑browser quirks, and best practices for efficient animation and task splitting.

JavaScript animationbrowser renderingevent loop
0 likes · 15 min read
Why requestAnimationFrame Beats setTimeout: Deep Dive into the Browser Event Loop
ByteDance Web Infra
ByteDance Web Infra
Sep 16, 2021 · Backend Development

Deep Dive into Node.js Architecture and Core Module Implementation

This article provides a comprehensive overview of Node.js’s architecture, including its composition, code structure, startup process, event loop phases, process and thread management, core modules such as Cluster, libuv thread pool, signal handling, file operations, and networking protocols, illustrating how the runtime integrates V8 and operating‑system features.

Node.jsbackendevent loop
0 likes · 29 min read
Deep Dive into Node.js Architecture and Core Module Implementation
Python Programming Learning Circle
Python Programming Learning Circle
Sep 11, 2021 · Fundamentals

A Comparative Overview of Python and JavaScript Coroutines

This article compares the evolution, concepts, and practical implementations of coroutines in Python and JavaScript, explaining their histories, core mechanisms such as async/await, event loops, and providing side‑by‑side code examples to help newcomers understand asynchronous programming in both languages.

Pythonasyncawait
0 likes · 15 min read
A Comparative Overview of Python and JavaScript Coroutines
ByteFE
ByteFE
Aug 12, 2021 · Frontend Development

How JavaScript’s Single Thread Handles Async and What startTransition Changes

Although JavaScript runs on a single thread, it can handle asynchronous operations through mechanisms like setTimeout, and React 18’s startTransition lets developers separate urgent UI updates from deferred work, improving responsiveness by scheduling non‑urgent tasks after urgent ones complete.

FrontendJavaScriptReAct
0 likes · 6 min read
How JavaScript’s Single Thread Handles Async and What startTransition Changes
Weekly Large Model Application
Weekly Large Model Application
Jun 16, 2021 · Fundamentals

Understanding libuv’s Design: A Deep Dive into Its Event Loop and Cross‑Platform Architecture

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.

Node.jsThread Poolasynchronous I/O
0 likes · 9 min read
Understanding libuv’s Design: A Deep Dive into Its Event Loop and Cross‑Platform Architecture
macrozheng
macrozheng
Jun 3, 2021 · Backend Development

How Redis Starts: Inside the Server’s Event Loop and Reactor Model

This article walks through Redis's startup sequence, explaining how the server creates a listening socket, registers events with the aeFileEvent system, runs a single‑threaded select‑based event loop, and processes client commands using the Reactor pattern, complete with code examples and diagrams.

Reactor patternRedisbackend development
0 likes · 8 min read
How Redis Starts: Inside the Server’s Event Loop and Reactor Model
Tencent Cloud Developer
Tencent Cloud Developer
May 31, 2021 · Frontend Development

Understanding Vue.nextTick and the JavaScript Event Loop

Vue.nextTick schedules callbacks using a graceful‑degradation chain (Promise, MutationObserver, setImmediate, setTimeout) that leverages the JavaScript event‑loop’s micro‑task queue, ensuring DOM mutations are applied instantly but rendered after microtasks and before macrotasks, while the browser’s multi‑threaded architecture coordinates rendering, timers, and network work.

JavaScriptVue.jsevent loop
0 likes · 12 min read
Understanding Vue.nextTick and the JavaScript Event Loop
Open Source Tech Hub
Open Source Tech Hub
Apr 14, 2021 · Backend Development

How Redis Implements Efficient I/O Multiplexing with select, epoll, and kqueue

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.

I/O multiplexingRedisSELECT
0 likes · 14 min read
How Redis Implements Efficient I/O Multiplexing with select, epoll, and kqueue
Liangxu Linux
Liangxu Linux
Apr 12, 2021 · Backend Development

Why Is Nginx So Fast? Inside Its Process and Event Models

This article explains Nginx’s high performance by dissecting its multi‑process architecture, master‑worker model, event‑driven handling using epoll, request lifecycle, module types, comparison with Apache, and I/O models such as select, poll, and epoll, plus configuration limits for maximum connections.

IO MultiplexingProcess Modelevent loop
0 likes · 11 min read
Why Is Nginx So Fast? Inside Its Process and Event Models
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Mar 31, 2021 · Backend Development

Unveiling libuv’s Linux Event Loop: epoll, Thread Pools, and Timers Explained

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.

LinuxThread PoolTimers
0 likes · 34 min read
Unveiling libuv’s Linux Event Loop: epoll, Thread Pools, and Timers Explained
Selected Java Interview Questions
Selected Java Interview Questions
Mar 8, 2021 · Databases

Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture and Implementation

This article explains how Redis evolves from a single‑threaded event‑driven cache to using Lazy Free for asynchronous key deletion and multi‑threaded I/O for improved performance, detailing the underlying mechanisms, code implementations, limitations, and comparisons with Tair's threading model.

Database PerformanceLazy FreeMultithreaded I/O
0 likes · 16 min read
Understanding Redis Lazy Free and Multi‑Threaded I/O: Architecture and Implementation
Tencent Cloud Developer
Tencent Cloud Developer
Feb 22, 2021 · Databases

Deep Dive into Redis Multi-Threaded Network Model: From Single-Threaded Reactor to I/O Threading

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
Deep Dive into Redis Multi-Threaded Network Model: From Single-Threaded Reactor to I/O Threading
Liangxu Linux
Liangxu Linux
Dec 30, 2020 · Backend Development

How Servers Serve Millions: Processes, Threads, and Event Loops Explained

This article explains how servers handle massive concurrent requests by evolving from simple multi‑process models to lightweight threads, then to event‑driven architectures with I/O multiplexing, highlighting the trade‑offs of blocking versus non‑blocking I/O and the role of coroutines.

IO Multiplexingconcurrencyevent loop
0 likes · 12 min read
How Servers Serve Millions: Processes, Threads, and Event Loops Explained
JD Retail Technology
JD Retail Technology
Dec 28, 2020 · Backend Development

Simplified Analysis of Netty Server and Client Startup and Communication

This article provides a concise, code‑driven walkthrough of Netty's core components—including event‑loop groups, channel initialization, pipeline handling, and the server‑client handshake process—by simplifying the original source to highlight the essential mechanisms behind asynchronous network communication in Java.

Channel pipelineJava NIONetty
0 likes · 19 min read
Simplified Analysis of Netty Server and Client Startup and Communication
vivo Internet Technology
vivo Internet Technology
Nov 25, 2020 · Fundamentals

Understanding JavaScript Event Loop: Browser and Node.js Models

The article explains JavaScript’s single‑threaded execution stack and how the event loop—using an event queue, micro‑tasks, and macro‑tasks—coordinates asynchronous operations in browsers and Node.js, detailing libuv’s stages and showing how this model enables non‑blocking, concurrent programming.

AsynchronousBrowserNode.js
0 likes · 9 min read
Understanding JavaScript Event Loop: Browser and Node.js Models
OPPO Kernel Craftsman
OPPO Kernel Craftsman
Nov 6, 2020 · Mobile Development

Overview of CHRE (Context Hub Runtime Environment) Architecture, Code Structure, and Event Processing

CHRE (Context Hub Runtime Environment) is an event‑driven, single‑threaded framework that hosts nanoapps on a sensor hub, organizing its source tree into API, Core, PAL, Platform, Apps, and Util directories, and managing events through a singleton EventLoopManager that initializes, queues, and dispatches system and nanoapp events.

AndroidCHREContext Hub
0 likes · 7 min read
Overview of CHRE (Context Hub Runtime Environment) Architecture, Code Structure, and Event Processing
NetEase Cloud Music Tech Team
NetEase Cloud Music Tech Team
Oct 19, 2020 · Frontend Development

Understanding JavaScript Concurrency, Asynchronous I/O, and the Event Loop

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.

JavaScriptNode.jsasynchronous I/O
0 likes · 13 min read
Understanding JavaScript Concurrency, Asynchronous I/O, and the Event Loop
vivo Internet Technology
vivo Internet Technology
Sep 16, 2020 · Fundamentals

JavaScript Event Loop: Macro Tasks vs Micro Tasks Execution Analysis

The article examines JavaScript’s event loop by contrasting macro‑tasks and micro‑tasks, tracing their spec‑defined origins, showing how callbacks, timers, Promises, async/await and generators are queued, and highlighting differences between browsers and Node.js (pre‑v11 vs v11+) that affect execution timing.

Asynchronous ProgrammingBrowser ImplementationCallback Mechanism
0 likes · 12 min read
JavaScript Event Loop: Macro Tasks vs Micro Tasks Execution Analysis
JavaEdge
JavaEdge
Sep 2, 2020 · Backend Development

How Redis Handles File and Time Events: Inside the Event Loop

This article explains Redis server's event-driven architecture, detailing how file events (read/write) and time events are processed, illustrated with state diagrams, pseudocode, and examples that show the interaction, scheduling, and impact on server performance.

File EventsRedisServer Architecture
0 likes · 12 min read
How Redis Handles File and Time Events: Inside the Event Loop
37 Interactive Technology Team
37 Interactive Technology Team
May 9, 2020 · Frontend Development

Understanding Asynchronous Programming in JavaScript: Event Loop, Tasks, and Promise Implementation

The article explains JavaScript’s single‑threaded nature and how asynchronous programming—using callbacks, timers, Ajax, and Promises—relies on the event loop to manage macro‑tasks and micro‑tasks, illustrates execution order, warns against callback hell, and provides a custom Promise implementation.

JavaScriptMicrotaskPromise
0 likes · 14 min read
Understanding Asynchronous Programming in JavaScript: Event Loop, Tasks, and Promise Implementation
JD Retail Technology
JD Retail Technology
Mar 30, 2020 · Mobile Development

Understanding iOS RunLoop: Concepts, Functions, and Practical Applications

This article explains the iOS RunLoop mechanism, its role in keeping apps responsive, how it interacts with UIApplicationMain, timers, thread management, and various RunLoop modes, and provides practical examples for using RunLoop to maintain thread life cycles and improve UI performance.

NSTimerRunLoopThread Management
0 likes · 10 min read
Understanding iOS RunLoop: Concepts, Functions, and Practical Applications
ITPUB
ITPUB
Feb 2, 2020 · Backend Development

How Redis Starts: A Deep Dive into server.c Initialization

This article explains the step‑by‑step process Redis follows to launch, from executing the redis‑server binary, initializing the server struct, loading configuration files, setting up data structures, restoring persistence, to entering the event loop.

C programmingRedisServer Initialization
0 likes · 6 min read
How Redis Starts: A Deep Dive into server.c Initialization
政采云技术
政采云技术
Dec 29, 2019 · Backend Development

Unveiling Node.js: How Processes, Threads, and Clusters Really Work

This article explains Node.js's internal concurrency model, covering the distinction between processes and threads, debunking the single‑thread myth, and detailing how the event loop, child processes, cluster mode, and worker_threads enable high‑performance, multi‑core execution.

ClusterNode.jschild_process
0 likes · 17 min read
Unveiling Node.js: How Processes, Threads, and Clusters Really Work
Ziru Technology
Ziru Technology
Aug 29, 2019 · Backend Development

Inside Redis: How Initialization and Event Loop Power the Server

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 multiplexingRedisServer Initialization
0 likes · 13 min read
Inside Redis: How Initialization and Event Loop Power the Server
Xueersi Online School Tech Team
Xueersi Online School Tech Team
Jul 12, 2019 · Fundamentals

Understanding Google V8 Engine Promise Implementation and the JavaScript Event Loop

This article explains the evolution of Google V8's Promise implementation, details the JavaScript single‑threaded event loop with macro‑ and micro‑tasks, describes various programming models, and walks through the internal V8 code that realizes Promise construction, chaining, and utility methods such as Promise.all and Promise.race.

JavaScriptPromiseV8
0 likes · 10 min read
Understanding Google V8 Engine Promise Implementation and the JavaScript Event Loop
MaoDou Frontend Team
MaoDou Frontend Team
Jul 2, 2019 · Frontend Development

Mastering JavaScript Promises: Event Loop, Tasks, and Advanced Patterns

This article explains JavaScript’s event mechanism, distinguishes macro‑ and micro‑tasks, and provides a comprehensive guide to using Promises—including their states, API methods like then, catch, finally, and utilities such as all, race, with practical code examples and common pitfalls.

JavaScriptPromiseasync
0 likes · 12 min read
Mastering JavaScript Promises: Event Loop, Tasks, and Advanced Patterns
MaoDou Frontend Team
MaoDou Frontend Team
Jun 18, 2019 · Frontend Development

How a Joke Sorting Algorithm Reveals JavaScript’s Event Loop Mechanics

Discover how a playful setTimeout‑based sorting trick leverages JavaScript’s event loop to produce correct ordering, while explaining the core concepts of synchronous vs asynchronous tasks, the execution stack, task queue, and why this method isn’t practical for large datasets.

AsynchronousJavaScriptSorting Algorithm
0 likes · 6 min read
How a Joke Sorting Algorithm Reveals JavaScript’s Event Loop Mechanics
Architect's Tech Stack
Architect's Tech Stack
Apr 25, 2019 · Backend Development

Redis I/O Multiplexing: Design, Implementation, and Code Walkthrough

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.

I/O multiplexingReactor patternRedis
0 likes · 11 min read
Redis I/O Multiplexing: Design, Implementation, and Code Walkthrough
MaGe Linux Operations
MaGe Linux Operations
Dec 2, 2018 · Backend Development

Master Python asyncio: From Coroutines to Event Loops Explained

This article introduces Python's asyncio library, explains how coroutines are defined and run, demonstrates event‑loop management with run_until_complete and run_forever, covers callbacks, gathering multiple coroutines, and best practices for closing loops, all illustrated with clear code screenshots.

Asynchronous Programmingasyncioconcurrency
0 likes · 7 min read
Master Python asyncio: From Coroutines to Event Loops Explained
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Oct 23, 2018 · Frontend Development

Mastering JavaScript Macrotasks, Microtasks, and Promise Timing

This article explains the differences between macrotasks and microtasks in the JavaScript event loop, shows how they affect Promise execution, provides practical code examples, and discusses how frameworks like Vue implement task scheduling, helping developers avoid dead‑loops and improve performance.

JavaScriptPromiseevent loop
0 likes · 13 min read
Mastering JavaScript Macrotasks, Microtasks, and Promise Timing
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Sep 30, 2018 · Fundamentals

Why Does setTimeout Run After Promise.then? Unraveling JavaScript’s Event Loop

This article explains how JavaScript’s single‑threaded model achieves asynchronous behavior through macro‑tasks and micro‑tasks, compares the browser and Node.js event‑loop implementations, and demonstrates the timing differences between setTimeout, setImmediate, and process.nextTick with practical code examples.

BrowserJavaScriptNode.js
0 likes · 9 min read
Why Does setTimeout Run After Promise.then? Unraveling JavaScript’s Event Loop
UC Tech Team
UC Tech Team
Sep 25, 2018 · Frontend Development

Understanding JavaScript Event Loop: Theory and Practice

This article explains the JavaScript Event Loop mechanism in depth, covering the call stack, heap memory, macro‑ and micro‑tasks, and their queues, and demonstrates the execution order through detailed examples and step‑by‑step visualizations of multiple event‑loop cycles.

JavaScriptNode.jsasync
0 likes · 7 min read
Understanding JavaScript Event Loop: Theory and Practice
21CTO
21CTO
Aug 27, 2018 · Frontend Development

Mastering Browser Architecture: From Multi‑Process to JS Event Loop

This comprehensive guide walks experienced front‑end developers through the browser's multi‑process model, internal threading, rendering pipeline, JavaScript single‑threaded execution, event loop mechanics, Web Workers, and performance‑related concepts like macrotasks, microtasks, and hardware‑accelerated compositing.

BrowserFrontendJavaScript
0 likes · 35 min read
Mastering Browser Architecture: From Multi‑Process to JS Event Loop
Tencent IMWeb Frontend Team
Tencent IMWeb Frontend Team
Aug 20, 2018 · Frontend Development

Mastering Browser Processes, Threads, and the JavaScript Event Loop

This comprehensive guide walks you through browser multi‑process architecture, the relationship between processes and threads, the rendering pipeline, Web Workers, and the intricacies of JavaScript's single‑threaded execution and event‑loop mechanisms, providing a solid knowledge framework for front‑end developers.

BrowserJavaScriptWeb Workers
0 likes · 33 min read
Mastering Browser Processes, Threads, and the JavaScript Event Loop