一、什么是事件循环?
事件循环(Event Loop)是一种用于管理异步任务执行顺序的调度机制。
它通常运行在一个线程中,负责协调:
- 同步代码的执行。
- 异步任务的注册。
- 回调函数的调度。
- 定时器任务的触发。
- I/O 操作完成后的结果处理。
- Promise、Future 和协程的恢复执行。
事件循环最重要的作用是:当某个任务需要等待 I/O、定时器或其他异步操作时,不必一直占用执行线程,而是让线程继续处理其他可执行任务。
例如,JavaScript 中:
console.log("开始");
setTimeout(() => {
console.log("定时器回调");
}, 1000);
console.log("结束");
输出:
开始
结束
定时器回调
虽然定时器回调在代码中先于最后一条 console.log 注册,但它不会立即执行。
JavaScript 主线程先执行当前同步代码,定时器到期后,回调才有机会进入事件循环的后续调度过程。
1.1 为什么需要事件循环?
传统同步程序通常按照代码顺序执行。
假设程序需要执行三个操作:
- 读取文件。
- 请求远程接口。
- 计算结果。
如果所有操作都采用阻塞方式,线程可能在等待文件和网络响应时无法执行其他任务。
事件循环通过异步机制改善这一问题。
flowchart TB
A["开始执行任务"] --> B["发起异步 I/O"]
B --> C["注册完成回调"]
C --> D["线程继续执行其他任务"]
D --> E["I/O 操作在后台进行"]
E --> F["I/O 操作完成"]
F --> G["回调进入可执行队列"]
G --> H["事件循环调度回调"]
H --> I["处理 I/O 结果"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
需要注意:
事件循环并不意味着异步操作本身一定由事件循环线程执行。
网络 I/O、文件 I/O、定时器和其他异步操作,可能由操作系统、运行时线程池或专门的 I/O 机制完成。事件循环主要负责调度这些操作完成后的后续处理。
二、事件循环的核心组成
不同语言和运行时的事件循环实现有所区别,但通常可以从以下几个概念理解。
2.1 调用栈(Call Stack)
调用栈用于管理当前正在执行的函数调用。
当函数被调用时,会创建对应的栈帧;函数执行结束后,栈帧退出。
例如:
function first() {
second();
}
function second() {
console.log("执行 second");
}
first();
执行过程:
调用 first()
|
v
first() 入栈
|
v
调用 second()
|
v
second() 入栈
|
v
执行 console.log()
|
v
second() 出栈
|
v
first() 出栈
调用栈中的任务通常按照后进先出(LIFO)的方式管理。
在 JavaScript 中,事件循环不会在当前同步调用栈尚未执行完成时,直接中断普通 JavaScript 代码去执行另一个回调。
2.2 任务队列(Task Queue)
任务队列用于存放等待执行的任务或回调。
常见任务来源包括:
- 定时器。
- 用户交互事件。
- 网络请求完成事件。
- 文件操作完成事件。
- 消息通信。
- Promise 后续处理。
任务队列并不一定只有一个。
例如,JavaScript 将任务区分为宏任务和微任务;Python asyncio 则使用事件循环内部的回调队列和定时器管理结构。
因此,不能将所有语言的事件循环都理解为一个简单 FIFO 队列。
2.3 事件循环(Event Loop)
事件循环负责不断检查是否存在可以执行的任务,并根据运行时规定的调度策略执行它们。
一个简化的事件循环模型:
flowchart TB
A["事件循环启动"] --> B{"调用栈是否空闲?"}
B -->|"否"| C["继续执行当前代码"]
C --> B
B -->|"是"| D["检查可执行任务"]
D --> E{"是否存在任务?"}
E -->|"是"| F["取出任务并执行"]
F --> B
E -->|"否"| G["等待新事件或任务"]
G --> D
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#FFF5DE,stroke:#E8D29A,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这是用于理解的抽象模型。真实运行时可能有多个任务队列、不同优先级、阶段划分以及专门的 I/O 轮询机制。
2.4 异步任务源(Async Sources)
异步任务源负责产生后续需要处理的事件。
例如:
| 任务源 | 典型场景 |
|---|---|
| Timer | 定时器到期 |
| Network I/O | 网络请求完成 |
| File I/O | 文件读取完成 |
| User Event | 鼠标点击、键盘输入 |
| Message | 消息通道收到数据 |
| Promise / Future | 异步操作完成 |
| Socket | 网络连接或数据可读写 |
这些任务源通常与操作系统和运行时协作。
三、事件循环的完整工作流程
事件循环的运行过程可以分成几个阶段。
3.1 注册异步任务
程序执行异步操作时,首先向运行时提交任务。
例如:
setTimeout(() => {
console.log("定时器完成");
}, 1000);
运行时会登记定时器及其回调。
当前 JavaScript 调用栈不需要等待一秒钟,可以继续执行后续代码。
3.2 等待异步操作完成
异步操作可能由不同机制执行:
- 操作系统异步 I/O。
- 运行时内部线程池。
- 网络协议栈。
- 定时器设施。
- 浏览器提供的 Web API。
这些机制负责等待操作完成,并通知运行时。
3.3 将回调加入调度队列
当异步操作达到触发条件后,对应的回调会进入运行时规定的可执行队列或任务调度结构。
需要注意,任务完成和回调立即执行是两件不同的事情。
如果当前线程正在执行耗时的同步代码,即使定时器已经到期,回调也可能无法立即执行。
3.4 事件循环调度任务
事件循环根据任务类型和调度规则选择可执行任务。
在 JavaScript 中,需要特别关注宏任务和微任务的区别。
在 Python asyncio 中,则需要关注就绪回调、定时器和协程任务的调度。
3.5 执行回调并恢复任务
事件循环执行回调后,回调可能:
- 处理异步操作结果。
- 修改程序状态。
- 创建新的异步任务。
- 注册新的定时器。
- 继续等待其他 I/O 操作。
完整流程:
flowchart TB
A["执行同步代码"] --> B["发起异步操作"]
B --> C["运行时注册任务"]
C --> D["异步操作等待完成"]
D --> E["操作完成并产生事件"]
E --> F["回调进入调度队列"]
F --> G{"当前执行线程是否空闲?"}
G -->|"否"| H["等待当前任务完成"]
H --> G
G -->|"是"| I["事件循环取出任务"]
I --> J["执行回调或恢复协程"]
J --> K{"是否产生新异步任务?"}
K -->|"是"| B
K -->|"否"| L["继续检查其他任务"]
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style G fill:#FFF5DE,stroke:#E8D29A,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style K fill:#FFF5DE,stroke:#E8D29A,color:#334155
style L fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
四、JavaScript 事件循环:宏任务与微任务
JavaScript 事件循环是理解异步编程最典型的案例之一。
在浏览器环境中,事件循环由 HTML 标准定义;在 Node.js 中,事件循环由 Node.js 和 libuv 等组件共同实现。
两者存在相似概念,但具体调度阶段并不完全相同。
4.1 宏任务(Macrotask / Task)
宏任务是 JavaScript 运行时调度的一类任务。
常见来源包括:
- 整体脚本执行。
setTimeout()。setInterval()。- 用户交互事件。
- 部分 I/O 回调。
- 消息事件。
例如:
console.log("同步任务 1");
setTimeout(() => {
console.log("宏任务");
}, 0);
console.log("同步任务 2");
输出:
同步任务 1
同步任务 2
宏任务
setTimeout(..., 0) 并不意味着回调立即执行。
它表示定时器满足最小延迟条件后,回调才有资格进入后续任务调度。
实际执行还受到当前调用栈、任务调度和运行时负载影响。
4.2 微任务(Microtask)
微任务是一类在当前任务执行完成后、浏览器继续执行后续任务之前需要处理的任务。
常见微任务来源包括:
Promise.then()。Promise.catch()。Promise.finally()。queueMicrotask()。MutationObserver回调。
例如:
console.log("同步任务");
setTimeout(() => {
console.log("宏任务");
}, 0);
Promise.resolve().then(() => {
console.log("微任务");
});
console.log("同步任务结束");
输出:
同步任务
同步任务结束
微任务
宏任务
原因是当前脚本任务执行完成后,运行时会先执行微任务检查点,再进入后续任务调度。
4.3 宏任务与微任务的执行顺序
在浏览器 JavaScript 中,可以将典型调度过程概括为:
- 执行当前任务。
- 当前任务执行完成。
- 执行微任务检查点,处理微任务。
- 如果微任务执行过程中又产生微任务,继续处理。
- 微任务队列清空后,浏览器有机会进行渲染。
- 继续选择后续任务。
flowchart TB
A["开始执行当前 Task"] --> B["执行同步代码"]
B --> C["当前 Task 结束"]
C --> D["执行 Microtask Queue"]
D --> E{"是否还有微任务?"}
E -->|"是"| F["执行下一个微任务"]
F --> D
E -->|"否"| G["浏览器可进行渲染"]
G --> H["选择下一个 Task"]
H --> A
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#FFF5DE,stroke:#E8D29A,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
注意:
- 微任务通常具有比后续普通任务更高的调度优先级。
- 微任务队列持续产生新任务时,可能长期无法清空。
- 微任务执行完成后,浏览器才有机会进行渲染。
- 浏览器渲染不是每执行一个宏任务就必然发生一次。
4.4 微任务为什么可能导致页面卡顿?
考虑以下代码:
function loop() {
Promise.resolve().then(loop);
}
loop();
每次微任务执行时,都会创建一个新的微任务。
由于微任务检查点需要持续处理新产生的微任务,队列可能一直无法清空。
这会阻止浏览器进入后续任务调度和渲染机会。
结果可能是:
- 页面无法及时刷新。
- 用户点击事件无法及时响应。
- 动画出现卡顿。
- CPU 长时间占用。
因此,不应将大量持续计算任务全部放入微任务。
如果需要将工作分批执行,可以考虑:
setTimeout()。MessageChannel。requestAnimationFrame()。requestIdleCallback()(需要考虑浏览器支持情况)。
4.5 综合执行顺序示例
console.log("1");
setTimeout(() => {
console.log("2");
Promise.resolve().then(() => {
console.log("3");
});
}, 0);
Promise.resolve().then(() => {
console.log("4");
});
console.log("5");
输出:
1
5
4
2
3
分析:
| 顺序 | 执行内容 | 原因 |
|---|---|---|
| 1 | 输出 1 | 同步代码 |
| 2 | 注册定时器 | 不立即执行回调 |
| 3 | 注册 Promise 微任务 | 等待当前任务结束 |
| 4 | 输出 5 | 同步代码继续执行 |
| 5 | 输出 4 | 当前任务结束后执行微任务 |
| 6 | 输出 2 | 定时器回调进入后续任务调度 |
| 7 | 输出 3 | 定时器回调创建的微任务在该回调任务结束后执行 |
这个例子说明:微任务不仅可以由最初的同步代码创建,也可以在宏任务回调执行期间创建。
五、JavaScript 中的事件循环与浏览器渲染
浏览器事件循环不仅管理 JavaScript 任务,还需要协调页面渲染。
5.1 浏览器主要执行流程
浏览器处理页面时,涉及:
- JavaScript 执行。
- DOM 更新。
- CSS 样式计算。
- 布局(Layout)。
- 绘制(Paint)。
- 合成(Composite)。
事件循环为浏览器提供执行任务和渲染的调度机会。
简化过程:
flowchart TB
A["执行 JavaScript Task"] --> B["执行 Microtasks"]
B --> C{"是否到达渲染机会?"}
C -->|"否"| D["继续处理后续任务"]
C -->|"是"| E["处理样式与布局"]
E --> F["绘制页面"]
F --> G["合成显示"]
G --> D
D --> H["选择下一个 Task"]
H --> A
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这只是概念性流程。实际浏览器渲染时机受到刷新率、页面可见性、任务调度和浏览器实现影响。
5.2 requestAnimationFrame
requestAnimationFrame() 用于请求浏览器在下一次适合进行动画更新的渲染机会执行回调。
例如:
function animate(timestamp) {
updateAnimation(timestamp);
requestAnimationFrame(animate);
}
requestAnimationFrame(animate);
适合:
- Canvas 动画。
- DOM 动画。
- 游戏渲染。
- 需要与屏幕刷新节奏协调的视觉更新。
它与 setTimeout() 的区别:
| 对比 | setTimeout | requestAnimationFrame |
|---|---|---|
| 主要用途 | 延迟执行回调 | 配合浏览器渲染 |
| 调度方式 | 定时器任务 | 渲染机会相关回调 |
| 时间控制 | 指定最小延迟 | 由浏览器渲染节奏决定 |
| 后台标签页 | 可能受到节流 | 通常会暂停或降低频率 |
| 典型场景 | 延迟操作 | 动画更新 |
requestAnimationFrame() 不等于固定 60 FPS,也不保证回调一定按照某个固定间隔执行。
5.3 页面卡顿的原因
假设浏览器主线程正在执行一个耗时 200ms 的同步任务。
在这段时间内:
- JavaScript 不能及时响应新的任务。
- 用户交互事件无法及时处理。
- 页面渲染机会可能被错过。
- 动画可能出现明显卡顿。
例如:
const start = Date.now();
while (Date.now() - start < 200) {
// 模拟长时间同步计算
}
console.log("计算完成");
这类长任务会阻塞主线程。
解决方式包括:
- 将任务拆分为多个小任务。
- 使用 Web Worker 执行 CPU 密集型计算。
- 使用合适的调度 API。
- 减少不必要的同步计算。
- 避免长时间占用微任务队列。
六、Node.js 中的事件循环
Node.js 也采用事件循环模型,但其实现与浏览器并不完全相同。
Node.js 的事件循环由 libuv 提供重要的底层支持,负责协调 I/O、定时器和回调等工作。
6.1 Node.js 事件循环的阶段
Node.js 事件循环包含多个阶段:
| 阶段 | 主要作用 |
|---|---|
| Timers | 执行满足条件的 setTimeout 和 setInterval 回调 |
| Pending Callbacks | 执行部分延迟到当前循环处理的系统级 I/O 回调 |
| Idle / Prepare | libuv 内部使用的阶段 |
| Poll | 获取新的 I/O 事件并执行相关回调 |
| Check | 执行 setImmediate() 回调 |
| Close Callbacks | 执行部分关闭事件回调 |
其中,Poll 阶段负责处理 I/O 相关事件,是 Node.js 事件循环的重要组成部分。
简化阶段示意:
flowchart TB
A["Timers"] --> B["Pending Callbacks"]
B --> C["Idle / Prepare"]
C --> D["Poll"]
D --> E["Check"]
E --> F["Close Callbacks"]
F --> A
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这是便于理解的阶段循环图,并不代表每一轮都会在所有阶段执行回调。
Node.js 版本升级可能影响部分阶段的具体时机。例如,Node.js 20 所使用的 libuv 1.45 起,定时器处理时机发生了调整,不能简单套用旧版本对 Timers 和 Poll 相对顺序的描述。
6.2 process.nextTick()
Node.js 提供 process.nextTick(),用于将回调安排到当前操作完成后的 next tick 阶段执行。
例如:
console.log("开始");
process.nextTick(() => {
console.log("nextTick");
});
Promise.resolve().then(() => {
console.log("Promise");
});
console.log("结束");
在常见 Node.js 环境中,输出为:
开始
结束
nextTick
Promise
process.nextTick() 并不是 libuv 事件循环中的一个普通阶段。
它具有独立的回调队列和特殊的调度时机。
如果持续递归调用 process.nextTick(),可能导致事件循环无法及时进入后续阶段。
6.3 setImmediate()
setImmediate() 用于将回调安排到事件循环的 Check 阶段执行。
例如:
setImmediate(() => {
console.log("Immediate");
});
setTimeout(() => {
console.log("Timeout");
}, 0);
在顶层代码中,这两个回调的先后顺序可能受到运行时启动时间和调度条件影响,不应依赖固定输出顺序。
如果在 I/O 回调内部安排两者,通常可以观察到 setImmediate() 先于 setTimeout(..., 0) 执行的情况,因为前者安排在当前循环的 Check 阶段,而后者需要等待定时器阶段满足执行条件。
6.4 Node.js 线程池与事件循环
Node.js 并不是所有异步操作都在事件循环线程中完成。
例如,部分文件系统操作、加密操作和 DNS 操作可能使用 libuv 线程池。
网络 I/O 则通常利用操作系统提供的异步或事件通知机制。
简化架构:
flowchart TB
A["JavaScript 主线程"] --> B["Node.js Event Loop"]
B --> C["定时器回调"]
B --> D["网络 I/O 事件"]
B --> E["线程池任务完成通知"]
F["libuv Thread Pool"] --> G["文件系统与部分计算任务"]
G --> E
H["操作系统网络 I/O"] --> D
C --> I["执行 JavaScript 回调"]
D --> I
E --> I
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style D fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
style G fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
linkStyle default stroke:#A3B8AC,stroke-width:1.5px
这也解释了为什么 Node.js 能够使用少量 JavaScript 执行线程处理大量 I/O 请求。
但 CPU 密集型 JavaScript 代码仍然可能阻塞主线程。
七、Python asyncio 中的事件循环
Python 的 asyncio 是基于事件循环实现异步编程的重要工具。
它使用协程、Task、Future 和事件循环管理异步任务。
7.1 asyncio 的核心组成
| 概念 | 作用 |
|---|---|
| Event Loop | 管理和调度异步任务 |
| Coroutine | 使用 async def 定义的协程对象 |
| Task | 将协程包装成可调度的任务 |
| Future | 表示尚未完成的异步结果 |
| await | 暂停当前协程,等待异步结果 |
例如:
import asyncio
async def fetch_data():
print("开始请求")
await asyncio.sleep(1)
print("请求完成")
return "data"
async def main():
result = await fetch_data()
print(result)
asyncio.run(main())
asyncio.sleep(1) 不会像传统的 time.sleep(1) 一样阻塞整个事件循环线程。
它会暂停当前协程,并让事件循环有机会调度其他任务。
7.2 协程如何与事件循环配合?
当协程执行到一个尚未完成的 await 时,当前协程会暂时挂起。
事件循环可以调度其他已经就绪的任务。
当等待的操作完成后,原协程会重新进入可执行状态。
flowchart TB
A["事件循环调度 Task A"] --> B["执行协程 A"]
B --> C["遇到 await"]
C --> D{"等待操作是否完成?"}
D -->|"否"| E["挂起协程 A"]
E --> F["调度其他就绪任务"]
F --> G["异步操作完成"]
G --> H["协程 A 重新就绪"]
H --> I["恢复协程 A"]
I --> J["继续执行后续代码"]
D -->|"是"| J
style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
style H fill:#F3EDFC,stroke:#C4B2E3,color:#334155
style I fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
style J fill:#E5F4EC,stroke:#A3CBB5,color:#334155
linkStyle default stroke:#A3B8AC,stroke-width:1.5px