# 消息队列和事件循环：页面是怎么活起来的|浏览器篇

> 本文深入解析浏览器中消息队列和事件循环的工作原理，讲解主线程如何调度和执行各种任务，帮助前端开发者理解页面响应和性能优化的底层机制。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/15-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%E5%92%8C%E4%BA%8B%E4%BB%B6%E5%BE%AA%E7%8E%AF%EF%BC%9A%E9%A1%B5%E9%9D%A2%E6%98%AF%E6%80%8E%E4%B9%88%E6%B4%BB%E8%B5%B7%E6%9D%A5%E7%9A%84
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.03
- 可见范围：免费部分

---

## 消息队列和事件循环：页面是怎么活起来的

- 渲染进程的主线程什么都要干：`DOM` 解析、样式、布局、执行 `JS`、处理用户输入
- 这么多事挤一个线程，靠的是消息队列 + 事件循环来排队调度
- 主线程是个死循环：从队列取任务 → 执行 → 再取，没任务就等着
- 别的线程、别的进程的消息也是丢进这个队列，由主线程按顺序处理
- 所以任何一个任务太长，后面的点击、渲染都要排队等

**页面能「活起来」，靠的是主线程上一个不停转的事件循环：所有要做的事都丢进消息队列，主线程一个个取出来执行。** 渲染进程的主线程要解析 `HTML`、算样式、布局、跑 `JS`、响应点击，这些事在时间上交错发生，只有一个线程，就得排队。消息队列就像银行叫号，谁来了先取号，主线程这个柜员办完一个叫下一个，没人就等着。理解这个模型，就能解释为什么一段死循环会让整个页面点不动、也不重绘。

前面我们讲到了每个渲染进程都有一个主线程，并且主线程非常繁忙，既要处理 DOM，又要计算样式，还要处理布局，同时还需要处理 JavaScript 任务以及各种输入事件。要让这么多不同类型的任务在主线程中有条不紊地执行，这就需要一个系统来统筹调度这些任务，这个统筹调度系统就是我们今天要讲的消息队列和事件循环系统。

在写这篇文章之前，我翻阅了大量的资料，却发现没有一篇文章能把消息循环系统给讲清楚的，所以我决定用一篇文章来专门介绍页面的事件循环系统。事件循环非常底层且非常重要，学会它能让你理解页面到底是如何运行的， 所以在本篇文章中，我们会将页面的事件循环给梳理清楚、讲透彻。

为了能让你更加深刻地理解事件循环机制，我们就从最简单的场景来分析，然后带你一步步了解浏览器页面主线程是如何运作的。

需要说明的是，文章中的代码我会采用 C++ 来示范。如果你不熟悉 C++，也没有关系，这里并没有涉及到任何复杂的知识点，只要你了解 JavaScript 或 Python，你就会看懂

- **主线程为什么不多开几个线程并行处理 `DOM`？**

  `DOM` 不是线程安全的，多线程同时改会有竞态，还得加锁，复杂度和开销都很大。所以浏览器选择单线程处理 `DOM` 和 `JS`，耗时的计算交给 `Worker`，但 `Worker` 不能碰 `DOM`。

- **页面里一段 `while(true)`，为什么连 `CSS` 的 `hover` 效果都没了？**

  `hover` 要响应鼠标事件、重新计算样式和绘制，这些都要排在主线程上，而主线程被死循环占着，永远轮不到。只有 `transform`、`opacity` 这类在合成线程跑的动画可能还在动。

- **事件循环和 `JS` 规范里的那个事件循环是一回事吗？**

  `JS` 语言规范只定义了 `Job`（`Promise` 回调）队列，事件循环是 `HTML` 规范定义的，由浏览器实现。`Node` 用的是 `libuv` 的事件循环，阶段划分不一样。

- **为什么 `setTimeout(fn, 0)` 不是立刻执行？**

  它只是把 `fn` 放进任务队列，要等当前任务执行完、前面排的任务也处理完才轮到。嵌套超过 `5` 层还会被浏览器强制成至少 `4ms`。

## 使用单线程处理安排好的任务

- 最简单的模型：所有任务提前写好，一个线程从头到尾顺序执行，执行完线程退出
- 适合确定性的批处理，但处理不了运行中途才来的新任务（比如用户点击）
- 这是推导事件循环的起点：后面一步步加「循环」和「队列」
- 浏览器主线程显然不能用这个模型，它要一直等新事件

**单线程顺序执行就是把任务列好，一个接一个跑完，线程就退出了，这是事件循环最原始的起点。** 比如一段脚本里算 `1 + 2`、再算 `20 / 5`、再打印结果，一路顺下来就结束了。这种模型简单可预测，但有个致命问题：执行过程中用户点了一下按钮，线程根本没有接收新任务的入口。页面是要一直等用户操作的，所以浏览器必须在这个基础上加循环和队列，这正是下一步要讲的。

我们先从最简单的场景讲起，比如有如下一系列的任务：

- 任务 1：1+2
- 任务 2：20/5
- 任务 3：7*8
- 任务 4：打印出任务 1、任务 2、任务 3 的运算结果

现在要在一个线程中去执行这些任务，通常我们会这样编写代码

```c
void MainThread(){
     int num1 = 1+2; // 任务 1
     int num2 = 20/5; // 任务 2
     int num3 = 7*8; // 任务 3
     print(" 最终计算的值为:%d,%d,%d",num,num2,num3)； // 任务 4
  }
```

在上面的执行代码中，我们把所有任务代码按照顺序写进主线程里，等线程执行时，这些任务会按照顺序在线程中依次被执行；等所有任务执行完成之后，线程会自动退出。可以参考下图来直观地理解下其执行过程：

![](https://s.poetries.top/gitee/2019/11/25.png)

**原理拆解：** 这种模型属于静态编排：任务集合和依赖关系在主线程启动前已经确定，所以源码中的语句顺序可以直接充当调度顺序。线程维护一个调用栈，同一时刻只执行栈顶对应的工作；前三个表达式依次求值并保存结果，打印语句必须等这些赋值完成后才能读取数据。入口函数返回且调用栈清空后，若没有事件循环或其他常驻机制，线程的工作便结束。

**具体实现：** 用 JavaScript 表达同一过程时，可以依次计算 `1 + 2`、`20 / 5` 和 `7 * 8`，再把三个结果传给 `console.log`。预期输出为 `3 4 56`，并且打印不可能插入到任一同步表达式的求值过程中。这里的数据依赖也约束了次序：如果第四项读取前三项的变量，就必须放在赋值之后，否则可能遇到未初始化错误或读到不符合预期的旧值。

**边界与反例：** 静态顺序只适合已知、短小且能够直接执行的任务。用户输入、网络响应和定时器回调到达时间不确定，无法在启动时全部写成一段固定任务序列；若主线程用耗时循环等待它们，还会阻塞后续工作。即使任务已知，长时间计算也会独占线程，顺序正确并不等于响应及时。

**工程验证：** 可在每项任务前后调用 `console.timeStamp`，或用浏览器开发者工具的 Performance 面板录制执行过程。应观察到这些同步计算位于同一个主线程任务内且连续发生，没有其他主线程任务穿插。若时间线上出现长任务，说明应拆分计算或转移工作，而不是改变几条同步语句的排列。

- **这种顺序执行的模型，生活中或者工程里有对应吗？**

  像一次性的构建脚本、`CLI` 工具跑一遍就退出，就是这个模型。没有交互，所有输入一开始就确定，跑完结束。

- **为什么浏览器主线程不能这么写？**

  页面打开后，用户随时会点击、滚动，网络响应和定时器也随时回来，这些都是运行中才产生的任务。顺序执行完就退出的线程，根本接不住它们。

- **一段同步脚本执行 `3` 秒，期间用户点了按钮，点击会丢吗？**

  不会丢，浏览器会把点击事件记进队列，等脚本跑完再处理。用户的感受是点了没反应，`3` 秒后才突然响应。这已经是加了队列之后的行为了。

- **那 `Node` 执行 `node script.js`，脚本跑完为什么进程有时不退出？**

  因为还有活跃的句柄，比如没关的 `server`、没清的 `setInterval`，`libuv` 的事件循环还有事要等。所有句柄都结束了，进程才退出。

## 在线程运行过程中处理新任务

- 要处理运行中途来的任务 → 加一个 `for(;;)` 循环，让线程一直活着
- 加事件：线程在循环里等待输入（比如键盘），来了就处理，处理完接着等
- 线程不退出、能接收新任务，这就是事件循环的雏形
- 但这个版本只能接收本线程自己的输入，别的线程发来的任务还接不住

**为了能处理执行过程中新来的任务，就在线程里加一个无限循环，不停地等事件、处理事件，这就是事件循环的雏形。** 原来是跑完就退出，现在变成「循环等输入 → 拿到输入就计算 → 输出结果 → 接着等」。比如循环里读用户在键盘敲的两个数字，敲一次算一次。这样线程能一直活着，能响应新的输入了。问题是这里的输入只能来自主线程自己，可浏览器里的任务大多来自别的线程，比如网络线程、`IO` 线程，这就引出了消息队列。

但并不是所有的任务都是在执行之前统一安排好的，大部分情况下，新的任务是在线程运行过程中产生的。比如在线程执行过程中，又接收到了一个新的任务要求计算“10+2”，那上面那种方式就无法处理这种情况了。

**要想在线程运行过程中，能接收并执行新的任务，就需要采用事件循环机制**。我们可以通过一个 for 循环语句来监听是否有新的任务，如下面的示例代码：

```js
//GetInput
// 等待用户从键盘输入一个数字，并返回该输入的数字
int GetInput(){
    int input_number = 0;
    cout<<" 请输入一个数:";
    cin>>input_number;
    return input_number;
}

// 主线程 (Main Thread)
void MainThread(){
     for(;;){
          int first_num = GetInput()；
          int second_num = GetInput()；
          result_num = first_num + second_num;
          print(" 最终计算的值为:%d",result_num)；
      }
}
```

相较于第一版的线程，这一版的线程做了两点改进。

- 第一点引入了循环机制，具体实现方式是在线程语句最后添加了一个for 循环语句，线程会一直循环执行。
- 第二点是引入了事件，可以在线程运行过程中，等待用户输入的数字，等待过程中线程处于暂停状态，一旦接收到用户输入的信息，那么线程会被激活，然后执行相加运算，最后输出结果。

通过引入事件循环机制，就可以让该线程“活”起来了，我们每次输入两个数字，都会打印出两数字相加的结果，你可以结合下图来参考下这个改进版的线程：

![](https://s.poetries.top/gitee/2019/11/26.png)

- **线程一直在 `for(;;)` 里转，不会把 `CPU` 占满吗？**

  真正的实现不是空转，没任务时线程会阻塞休眠，比如等条件变量或系统事件，有任务再被唤醒。示意代码里的循环只是表达逻辑。

- **这个模型和真正的浏览器事件循环差在哪？**

  差了消息队列。现在只能处理自己线程里同步等来的输入，而浏览器里网络返回、定时器到期、用户点击都是别的线程产生的，需要一个队列把任务交接给主线程。

- **事件循环里一个任务处理得慢，会怎样？**

  循环卡在处理那一步，下一个输入就只能等。所以事件驱动系统都有个原则：单个任务要短，耗时工作要切出去。

- **`Node` 的事件循环也是这个思路吗？**

  是的，`libuv` 也是一个循环，只是把等待分成了 `timers`、`poll`、`check` 等阶段，每个阶段处理对应类型的回调。

## 处理其他线程发送过来的任务

- 其他线程（`IO` 线程、网络线程、定时器）产生的任务，通过消息队列交给主线程
- 消息队列是先进先出：别的线程往队尾加，主线程从队头取
- 主线程循环：`takeTask()` 取任务 → 执行 → 再取，队列为空就等
- 多线程同时往队列里塞，队列操作要加锁
- 真实 `Chromium` 里有多个任务队列和优先级，用户输入通常更优先，不是一条严格的 `FIFO`

**别的线程产生的任务，是通过一个消息队列交给主线程的：别人往队尾塞，主线程从队头取。** 比如定时器到期、网络响应回来，这些事都不在主线程上发生，相关线程就把一个任务包装好丢进队列；主线程的循环每轮从队头取一个执行，执行完再取。因为好几个线程会同时往队列里加任务，队列本身要加锁。课程里讲的是一条队列的简化模型，实际 `Chromium` 有好几个任务队列，调度器会让输入事件这类更紧急的任务优先，所以别把它当成严格的全局先进先出。

```mermaid
sequenceDiagram
    autonumber
    participant Net as 网络线程
    participant Timer as 定时器线程
    participant Q as 消息队列
    participant Main as 渲染主线程
    Main->>Q: 循环取任务
    Q-->>Main: 队列空，阻塞等待
    Net->>Q: 响应到达，投递任务
    Timer->>Q: 定时器到期，投递任务
    Q-->>Main: 唤醒并交出队头任务
    Main->>Main: 执行网络回调
    Main->>Q: 再取下一个任务
    alt 当前任务太长
        Note over Q,Main: 后面的任务只能排队，页面表现为卡顿
    else 任务很短
        Q-->>Main: 交出定时器任务并执行
    end
```

上面我们改进了线程的执行方式，引入了事件循环机制，可以让其在执行过程中接受新的任务。不过在第二版的线程模型中，所有的任务都是来自于线程内部的，如果另外一个线程想让主线程执行一个任务，利用第二版的线程模型是无法做到的。

那下面我们就来看看其他线程是如何发送消息给渲染主线程的，具体形式你可以参考下图：

![](https://s.poetries.top/gitee/2019/11/27.png)

从上图可以看出，渲染主线程会频繁接收到来自于 IO 线程的一些任务，接收到这些任务之后，渲染进程就需要着手处理，比如接收到资源加载完成的消息后，渲染进程就要着手进行 DOM 解析了；接收到鼠标点击的消息后，渲染主线程就要开始执行相应的 JavaScript 脚本来处理该点击事件。

那么如何设计好一个线程模型，能让其能够接收其他线程发送的消息呢？

一个通用模式是使用消息队列。在解释如何实现之前，我们先说说什么是消息队列，可以参考下图：

![](https://s.poetries.top/gitee/2019/11/28.png)

从图中可以看出，消息队列是一种数据结构，可以存放要执行的任务。它符合队列“先进先出”的特点，也就是说要添加任务的话，添加到队列的尾部；要取出任务的话，从队列头部去取。

有了队列之后，我们就可以继续改造线程模型了，改造方案如下图所示：

![](https://s.poetries.top/gitee/2019/11/29.png)

从上图可以看出，我们的改造可以分为下面三个步骤：

- 添加一个消息队列；
- IO 线程中产生的新任务添加进消息队列尾部；
- 渲染主线程会循环地从消息队列头部中读取任务，执行任务。

有了这些步骤之后，那么接下来我们就可以按步骤使用代码来实现第三版的线程模型。

首先，构造一个队列。当然，在本篇文章中我们不需要考虑队列实现的细节，只是构造队列的接口：

```js
class TaskQueue{
  public:
  Task takeTask(); // 取出队列头部的一个任务
  void pushTask(Task task); // 添加一个任务到队列尾部
};
```

接下来，改造主线程，让主线程从队列中读取任务：

```c
TaskQueue task_queue；
void ProcessTask();
void MainThread(){
  for(;;){
    Task task = task_queue.takeTask();
    ProcessTask(task);
  }
}
```

在上面的代码中，我们添加了一个消息队列的对象，然后在主线程的 for 循环代码块中，从消息队列中读取一个任务，然后执行该任务，主线程就这样一直循环往下执行，因此只要消息队列中有任务，主线程就会去执行。

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part4/15-%E6%B6%88%E6%81%AF%E9%98%9F%E5%88%97%E5%92%8C%E4%BA%8B%E4%BB%B6%E5%BE%AA%E7%8E%AF%EF%BC%9A%E9%A1%B5%E9%9D%A2%E6%98%AF%E6%80%8E%E4%B9%88%E6%B4%BB%E8%B5%B7%E6%9D%A5%E7%9A%84
