控制事件循环执行顺序的技巧

怎么入门文章编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《手动控制事件循环执行顺序的方法取决于你使用的编程语言和框架。以下是一些常见语言中手动控制事件循环执行顺序的通用方法：1. JavaScript（Node.js / 浏览器环境）在 JavaScript 中，事件循环是异步的，但你可以通过以下方式影响其执行顺序：a. 使用 queueMicrotask()queueMicrotask(() => { console.log("微任务"); });微任务会比宏任务优先执行。b. 使用 Promise 和 then()Promise.resolve().then(() => { console.log("Promise 任务"); });Promise 的 .then() 是微任务，会在当前同步代码执行后立即执行。c. 使用 setTimeout() 或 setImmediate()setTimeout(() => { console.log("宏任务"); }, 0);宏任务会在当前同步代码结束后执行。d. 使用 process.nextTick()（仅限 Node.js）process.nextTick(() => { console.log("nextTick 任务"); });优先级高于 Promise 和 setTimeout。2. Python（asyncio）在 Python 中，你可以使用 asyncio 控制事件循环的执行顺序：a. **使用 await》，涉及到，有需要的可以收藏一下

手动控制事件循环的本质是利用API将任务插入不同队列以影响执行顺序，而非直接干预底层机制；2. process.nextTick()优先级最高，在当前宏任务后立即执行，甚至早于Promise微任务；3. Promise.then()属于微任务，在nextTick之后、宏任务前执行；4. setImmediate()在I/O回调后的check阶段执行，比setTimeout(0)更早且稳定；5. setTimeout(0)受系统最小延迟影响，在timers阶段执行，时机不如setImmediate可靠。

手动控制事件循环的执行顺序，听起来像个能完全掌控系统脉搏的超能力，但实际上，这更多是一种对事件调度机制的深刻理解和巧妙运用，而非字面意义上的“手动改写”运行时底层逻辑。我们能做的，是在其既定规则下，通过不同的API将任务放入不同的队列，从而影响它们的执行优先级和时机。

解决方案

要“控制”事件循环的执行顺序，核心在于理解Node.js（或浏览器）事件循环的不同阶段以及微任务（microtask）和宏任务（macrotask）的优先级。事件循环并非一个你可以直接调用API去暂停或跳过的东西，它是一个持续运行的机制，负责协调所有异步操作。我们的“控制”手段，其实是利用 process.nextTick()、Promise.resolve().then()、setImmediate() 和 setTimeout(0) 等API，将我们的回调函数“插入”到事件循环的特定位置。

简单来说：

1. process.nextTick()：拥有最高的优先级，它的回调会在当前事件循环阶段的任何其他任务（包括微任务和宏任务）之前执行。可以理解为在当前执行栈清空后，立即执行，甚至比微任务队列清空还早。
2. Promise.resolve().then()：属于微任务，会在当前宏任务执行完毕后，所有 process.nextTick() 回调执行完毕后，立即清空微任务队列时执行。
3. setImmediate()：属于宏任务，在I/O事件回调之后，但在下一个事件循环周期中的 setTimeout 之前执行。它在Node.js的“check”阶段运行。
4. setTimeout(fn, 0)：属于宏任务，在Node.js的“timers”阶段运行。它会在当前事件循环迭代中的所有I/O操作和 setImmediate 任务之后，或者在下一个事件循环迭代的开始阶段执行，具体取决于系统负载和计时器精度。

所以，所谓的“手动控制”，就是根据我们对任务优先级的需求，选择合适的API来调度它们。

为什么直接“控制”事件循环是伪命题？

我觉得，我们常常把“控制”这个词用得过于宽泛。当谈到事件循环，它更像是一个精心设计的操作系统核心调度器，而不是一个可以随意拨弄的开关。Node.js的事件循环，或者说V8引擎与libuv库共同构建的这个异步I/O模型，其核心目标就是高效、非阻塞地处理大量并发操作。它是一个运行时机制，不是一个对外暴露的、允许你直接介入其内部调度逻辑的API。

在我看来，试图直接“控制”事件循环，就像是想在高速公路上，亲自指挥每一辆车的变道和加速减速。这不仅不现实，而且一旦你真的有了这种“能力”，反而会破坏整个系统的稳定性和公平性。事件循环的精妙之处在于它的自动化和优先级管理，确保了CPU密集型任务不会长时间阻塞I/O，也保证了I/O操作完成后能及时得到处理。

我们所做的，是利用它提供的“钩子”（比如各种异步API），将我们的任务注册进去，然后事件循环会根据其内部规则，决定何时何地执行这些任务。这种“控制”更像是“影响”或“引导”，而非“命令”。一旦我们试图强行打破其固有的调度逻辑，例如通过无限递归的 process.nextTick 来“霸占”CPU，那么结果往往是程序崩溃或性能急剧下降，因为它违背了事件循环设计时的基本原则：非阻塞和公平性。

process.nextTick 与 Promise：微任务的优先级陷阱

process.nextTick 和 Promise.then() 都是微任务，但它们之间存在一个微妙而关键的优先级差异。在Node.js中，process.nextTick 的回调总是会在当前宏任务执行完毕后，立即执行，甚至在当前微任务队列（包括 Promise 回调）被清空之前。而 Promise.then() 的回调，则会在 process.nextTick 回调执行完毕后，作为微任务队列的一部分被清空。

这听起来有点绕，我们看个例子就清楚了：

console.log('Start');

process.nextTick(() => {
    console.log('process.nextTick callback 1');
});

Promise.resolve().then(() => {
    console.log('Promise.then callback 1');
});

process.nextTick(() => {
    console.log('process.nextTick callback 2');
});

Promise.resolve().then(() => {
    console.log('Promise.then callback 2');
});

console.log('End');

这段代码的输出通常是：

Start
End
process.nextTick callback 1
process.nextTick callback 2
Promise.then callback 1
Promise.then callback 2

你会发现，所有 nextTick 的回调都在所有 Promise 的回调之前执行了。这是因为在Node.js中，nextTick 队列的优先级高于微任务队列。

这个“优先级陷阱”在于，如果你在一个事件循环周期内大量使用 process.nextTick，它可能会导致 Promise 回调，甚至后续的宏任务（如 setTimeout 或 setImmediate）被“饿死”，因为 nextTick 会在每个阶段之间反复清空。在某些高并发或需要精细控制执行顺序的场景下，这可能是一个强大的工具，但滥用则会导致性能问题或不可预测的行为。所以，在使用时需要非常清楚其副作用，避免创建无限循环的 nextTick 导致事件循环停滞。

setImmediate 与 setTimeout(0)：宏任务的执行时机差异

当我们谈论宏任务的调度时，setImmediate 和 setTimeout(0) 是两个经常被拿来比较的API，它们都用于将任务推迟到当前事件循环的后续执行。然而，它们在Node.js事件循环中的执行时机却大相径庭。

setTimeout(fn, 0) 会将回调放入“timers”阶段的队列。这个阶段是事件循环的第一个阶段，用于执行那些到期的定时器。理论上 delay 为0表示立即执行，但在实际中，它会受到系统最小延迟（通常是4ms）的影响，而且必须等待当前所有正在执行的同步代码和微任务完成后，才会在下一个“timers”阶段被考虑执行。

setImmediate(fn) 则会将回调放入“check”阶段的队列。这个阶段位于事件循环的后期，在“poll”阶段（处理I/O事件）之后，但在下一个事件循环周期开始之前。它的设计初衷就是为了在当前I/O事件处理完毕后，立即执行一些任务。

让我们看一个经典的例子，尤其是在涉及到I/O操作时，它们的差异会更明显：

const fs = require('fs');

console.log('Start');

fs.readFile(__filename, () => {
    console.log('readFile callback');

    setTimeout(() => {
        console.log('setTimeout inside readFile');
    }, 0);

    setImmediate(() => {
        console.log('setImmediate inside readFile');
    });
});

setTimeout(() => {
    console.log('setTimeout outside readFile');
}, 0);

setImmediate(() => {
    console.log('setImmediate outside readFile');
});

console.log('End');

在大多数情况下，这段代码的输出会是：

Start
End
setTimeout outside readFile
setImmediate outside readFile
readFile callback
setImmediate inside readFile
setTimeout inside readFile

（注意：外部的 setTimeout 和 setImmediate 的顺序在没有I/O的情况下是随机的，但一旦有I/O，setImmediate 通常在I/O回调之后立即执行，而 setTimeout 则可能要等到下一个循环的定时器阶段。）

这里的关键点是：

• setImmediate 更“即时”：当你在I/O回调内部使用 setImmediate 时，它几乎会立即在I/O回调执行完毕后触发，因为它属于“check”阶段，紧随“poll”阶段（I/O处理）。
• setTimeout(0) 的不确定性：即使是 setTimeout(0)，它也可能因为事件循环的阶段切换和计时器队列的优先级，被推迟到下一个事件循环周期。在有I/O操作时，I/O回调会先执行，然后才是 setImmediate，最后才轮到 setTimeout。

所以，如果你想在当前I/O操作完成后，立即执行一个非阻塞任务，setImmediate 通常是更可靠的选择。而 setTimeout(0) 则更适合那些不需要严格即时性，只是想将任务推迟到下一个可用的宏任务时段执行的场景。理解这些差异，是有效调度Node.js异步任务的关键。

本篇关于《控制事件循环执行顺序的技巧》的介绍就到此结束啦，但是学无止境，想要了解学习更多关于文章的相关知识，请关注golang学习网公众号！