返回专栏
· 23 分钟阅读

事件循环(Event Loop)


一、什么是事件循环?

事件循环(Event Loop)是一种用于管理异步任务执行顺序的调度机制。

它通常运行在一个线程中,负责协调:

  • 同步代码的执行。
  • 异步任务的注册。
  • 回调函数的调度。
  • 定时器任务的触发。
  • I/O 操作完成后的结果处理。
  • Promise、Future 和协程的恢复执行。

事件循环最重要的作用是:当某个任务需要等待 I/O、定时器或其他异步操作时,不必一直占用执行线程,而是让线程继续处理其他可执行任务。

例如,JavaScript 中:

console.log("开始");

setTimeout(() => {
    console.log("定时器回调");
}, 1000);

console.log("结束");

输出:

开始
结束
定时器回调

虽然定时器回调在代码中先于最后一条 console.log 注册,但它不会立即执行。

JavaScript 主线程先执行当前同步代码,定时器到期后,回调才有机会进入事件循环的后续调度过程。

1.1 为什么需要事件循环?

传统同步程序通常按照代码顺序执行。

假设程序需要执行三个操作:

  1. 读取文件。
  2. 请求远程接口。
  3. 计算结果。

如果所有操作都采用阻塞方式,线程可能在等待文件和网络响应时无法执行其他任务。

事件循环通过异步机制改善这一问题。

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 中,可以将典型调度过程概括为:

  1. 执行当前任务。
  2. 当前任务执行完成。
  3. 执行微任务检查点,处理微任务。
  4. 如果微任务执行过程中又产生微任务,继续处理。
  5. 微任务队列清空后,浏览器有机会进行渲染。
  6. 继续选择后续任务。
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