setImmediate() vs setTimeout() 在 JavaScript 中的区别

在 JavaScript 中，setImmediate() 和 setTimeout() 都用于调度任务，但它们的工作方式不同。

JavaScript 的异步特性

JavaScript 以其非阻塞、异步行为而闻名，尤其是在 Node.js 环境中。如果你曾经参与过涉及定时器或回调的项目，你可能遇到过 setTimeout()，甚至 setImmediate()。乍一看，这两个函数似乎做的是同一件事——调度任务以便稍后运行。但如果你曾经一起运行它们，你可能会注意到一些有趣的行为。

尽管它们的目的相似，但 setImmediate() 和 setTimeout() 在底层的操作方式不同。如果你想知道为什么 setImmediate() 回调似乎一个接一个地运行，而 setTimeout() 回调则是间隔开的，本指南将为你解析其中的原因。

这不仅仅是 JavaScript 的一个怪癖；它与 Node.js 如何管理异步任务密切相关。理解这两个函数之间的差异将帮助你更好地控制代码的时间和执行顺序，这对于大型应用程序尤其重要，因为即使是时间上的微小失误也可能导致难以发现的错误。

我们将深入探讨事件循环，它如何处理这些定时器，以及为什么在一起使用它们时事情并不总是按预期发生。到最后，你将更清楚地了解何时使用 setTimeout() 或 setImmediate()，以满足你所需的时间行为。

行为差异

javascript">setImmediate(() => {console.log("setImmediate 1");
});setTimeout(() => {console.log("setTimeout 1");
}, 0);setTimeout(() => {console.log("setTimeout 2");
}, 0);setImmediate(() => {console.log("setImmediate 2");
});

当你运行这段代码时，你可能期望 setTimeout 回调按定义的顺序执行，然后是 setImmediate 回调。但你在控制台中看到的是：

javascript">setTimeout 1
setImmediate 1
setImmediate 2
setTimeout 2

如果这让你感到困惑，不要担心。让我们解开其中的原因。

事件循环

要理解这一点，我们需要快速了解 Node.js 如何管理异步操作。Node.js 的异步特性核心是事件循环。

在 Node.js 中，事件循环处理不同的阶段，每个阶段负责执行某些类型的回调。它帮助管理非阻塞任务，确保函数可以异步执行。在这些阶段中，有不同的队列。对于本次讨论，有两个队列是重要的：

宏任务队列：这是 setTimeout 和 setImmediate 等任务所在的地方。
微任务队列：这是 promises (Promise.then()) 和 process.nextTick() 回调所在的地方。

事件循环的工作原理

要理解 setTimeout() 和 setImmediate() 的工作原理，我们需要看看 Node.js 中的事件循环。事件循环允许 Node.js 处理异步代码。它在不同的阶段处理不同类型的操作，每个阶段负责特定的任务。

   ┌───────────────────────────┐
┌─>│           timers          │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │└───────────────────────────┘

定时器阶段：这是处理 setTimeout() 回调的地方。即使是 0 毫秒的延迟，它们也要等到下一次循环迭代才能执行。
待处理回调阶段：处理已完成的 I/O 事件，但我们的示例中没有，所以跳过这个阶段。
检查阶段：setImmediate() 回调在这里运行。它们在 I/O 任务之后立即执行，但在 setTimeout() 回调之前。
轮询阶段：处理新的传入 I/O 操作，如文件读取或网络请求。如果没有 I/O，事件循环会跳过这个阶段。
下一次循环迭代：在检查阶段之后，事件循环回到处理下一个定时器阶段，在那里 setTimeout() 回调最终运行。

`setTimeout()` 的 0 延迟

当你使用 setTimeout() 并设置延迟为 0 时，你实际上是在告诉 Node.js 在当前操作完成后尽快运行回调。然而，重要的是要记住，“尽快”仍然取决于事件循环的阶段。

javascript">setTimeout(() => {console.log("setTimeout 1 with 0 delay");
}, 0);setImmediate(() => {console.log("setImmediate 1");
});setTimeout(() => {console.log("setTimeout 2 with 0 delay");
}, 0);

输出结果：

setTimeout 1 with 0 delay
setImmediate 1
setTimeout 2 with 0 delay

即使延迟为 0，setTimeout() 回调仍然需要等待定时器阶段的下一次循环，因此不会立即运行。相反，它被放置在宏任务队列中，以便在下一个可用机会执行。

`setImmediate()`

另一方面，setImmediate() 设计用于在 I/O 事件完成后执行回调，在同一事件循环迭代中。这意味着 setImmediate() 回调在额外的定时器（如 setTimeout()）执行之前被处理，特别是在没有 I/O 的情况下。

在我们的示例中，由于没有 I/O 发生，两个 setImmediate() 回调会一个接一个地执行，然后才轮到第二个 setTimeout() 回调。

为什么 `setImmediate` 回调会一起运行？

相同的事件循环周期：两个 setImmediate 调用在事件循环的同一个周期（或循环）中被放置到宏任务队列中。Node.js 按顺序处理这些任务。
优先于 setTimeout()：即使 setTimeout() 设定了 0 延迟，这也不保证立即执行。setImmediate() 回调在当前周期中优先于 setTimeout() 任务。

现实世界的类比

想象一下在餐馆点餐和饮料。

你点了一道菜（代表 setTimeout(0)）。
厨师将其添加到订单队列中，一旦准备好就会送达。
同时，你要了一杯水（setImmediate()），由于它快速且容易准备，服务员会在你的食物完成之前立即送达。

在这个类比中，水（快速任务）首先被处理，即使两个订单几乎同时下达。菜（稍微复杂一些）稍后送达。

这种情况总是发生吗？

不一定。setImmediate() 和 setTimeout() 的行为可能取决于代码中发生的其他异步操作。如果有 I/O 操作，执行顺序可能会改变，因为 setImmediate() 只会在 I/O 事件完成后运行。

javascript">const fs = require("fs");fs.readFile("example.txt", () => {setTimeout(() => {console.log("setTimeout after I/O");}, 0);setImmediate(() => {console.log("setImmediate after I/O");});
});

输出结果：

setImmediate after I/O
setTimeout after I/O

在这种情况下，setImmediate() 总是在 setTimeout() 之前运行，因为事件循环在 I/O 回调之后优先处理 setImmediate()。

当没有 I/O 事件时，两个 setImmediate() 回调会一个接一个地运行，然后才轮到 setTimeout() 回调。

`process.nextTick()` 和 Promises

以下示例展示了 Node.js 中各种异步操作的处理方式：

javascript">setTimeout(() => {console.log("setTimeout");
}, 0);setImmediate(() => {console.log("setImmediate");
});Promise.resolve().then(() => {console.log("Promise then");
});process.nextTick(() => {console.log("process.nextTick");
});

输出结果：

process.nextTick
Promise then
setTimeout
setImmediate

process.nextTick()：这将在任何其他任务之前运行，甚至在微任务（如 Promises）之前。
Promise.then()：这是一个微任务，因此它在当前操作之后但在宏任务（如 setTimeout() 和 setImmediate()）之前运行。
setTimeout()：在微任务处理完之后运行。
setImmediate()：尽管它类似于 setTimeout()，但它在事件循环周期的后期运行，在当前 I/O 操作之后。

Node.js 的异步行为有时可能会令人困惑，特别是在处理 setTimeout() 和 setImmediate() 时。关键是理解事件循环以及任务在不同阶段的调度方式。