深入解析 Node.js 的回调队列

深入解析 Node.js 的回调队列

队列是 Node.js 中用于有效处理异步操作的一项重要技术。【视频教程推荐:node js教程 】

在本文中,我们将深入研究 Node.js 中的队列:它们是什么,它们如{ V k何工作(通过事件循环)以及它们的类型。

Node.j _ F 3s 中的队列是什么u n j 1 /

队列是 Node.js 中用于组织异步操作的数据结构。这些操作以不同的形式存在,包括HTTP请求、读取I _ u H { G或写h 4 R H入文件操作、流等。

在 Node.~ 9 : Bjs 中处理异步操作非常m 1 Q r b + d U E具有挑战性。

HTTP 请求期间可能会出现不可预测的延迟(或者更糟糕的可能性是没有结果),具体取决; y c G b e = S于网络质量。尝试用 Node.js 读写文件时也有可能会产生延迟,具体取决于文件的大小。

类似于计时器和其他的许多操作,异步操作完成的时间也有可能是不确定的。

在这些不同的延迟情况之下,Node.js 需要能够有效地处理所有这些操作f r d L -

Node.js 无法处理基于 first-start-first-handle (先开始先处理)或 first-finish-first-handle (先结束先处理)的操作。

之所以不能这样做的一个原因是,在一个异步操, 2 m L Y作中可能还会包含另一个异步操作。

为第一e ; `X L E + U异步过程留出空间意味着必须先要完成内部异步过程,然后才能考虑队列中的其他异步操作。s s - N f $ I

有许多情况需要 5 K p考虑,因此最好的选择是制定规则。这个规则影响了事件循环和队列在 Node.js 中的工作方式。

让我们简要地看一下 Node.js 是怎样处理异步操作的。

调用栈,事. H A g W件循环和回调队列

调用栈被用于跟踪当前正在执行的函数以及从何处开始运行。当一个函数将要执行时,它会被添加到调用堆栈中。这有助于 JavaScript 在执行函数后重新跟踪其处理步骤。

回调队列是在后台操作完成时把回调函数保存为异步操p y g作的队列。它们以先进先出(FIFO)的方式工作。我们将会在本文后面介绍不同类型的回调队列。

请注意,Node.js 负责所有异步活动,因为 JavaScript 可以利用其单线程性质来阻止产生新的线程/ b h d 1 8 3 u

在完成后台操作后,它还负责向回调队列添加函数r e $ @ 4。 JavaScript 本身与回调队列无关。同时事件循环会连续检_ j Z , 6 C Z X查调用栈是否D & 0 F t为空,以便可以从回调队| d % u Q V列中提取一个函数并添加到调用栈中。事件循环仅在执行所有同步, c x @ X x Z 9操作之后才检查队列。

那么,事件循环是按照什么样的顺序从队列中选择回调函数的呢?

首先,让我们看一下回调队列的五种主要类型。

回调队列的类型

IO 队列(IO queue)

IO操作是指涉及外部设备(如计算机的硬盘、网卡等)的操作。常见的操作包括读写文件操作、网络操作等。这些操作应该是异步的,因为_ 4 B u F k它们@ x M p留给 Node.js 处理。

JavaScript 无法访问计算机的内部设备。当执行此类操作时,JavaScript 会将其传输到 Node.js 以在后台处理。

完成后,它们将会8 X T h被转移到 IO 回调队列中,来进行事件循环,以转移到调用栈中执行。

计时器队列(Timer queue)

每个涉及 Node.js 计时器功能的操作(如 setTimeout()setInterval())都是要被添加到计时器队列N { d { u y J G的。

请注意,JavaScript 语言本身& 5 u e没有计时器功能。它使用 Node.js 提供的计时器 API(包括 setTimeout )执行与时间相关的操作。所以计时器操作是异步的。无论是G w x ? Z M . 2 秒还是 0 秒,JavaScrL s Z Cipt 都会把与时间相关的操作移交给 Node.js,然后将其完成并添加到计时器队列中。

例如:

setTimeout(function() {
conj [ Asole.log('s_ 8 x D 5 / zetTimeout');
}, 0)
console.log('yeah')
# 返回
yeah
setTimeout

在处理异步操作时,JavaScripy Y K O ` r } t Qt 会继续执行其他操作。只有在所有同步操作都已被处理完毕后,事件循环才会进入回调队列。

微任务队列(Microtask queue)

该队列分为两个队列:

  • 第一个队列包含因 process.nextTick 函数而延迟的函数。

事件循环执行的每个迭代称为一个 tick(时间刻度)。

process.nextTick 是一个函数,它在下一个 tick (即事件循环的下一个迭代)执行一个函数。微任务队N ) 4列需要存储此类函数,以便可以在下一个 tick 执行它们。

这意味着事件循环必须继续检$ y i查微任务队列中的此类函数,然后再进入其他队列。

  • 第二个队列包含因 promises 而延迟的函数。

如你8 _ m 9 J z ~所见,在 IO 和计时器队列中,所有与异步操作有关的内容都$ c c R % c f !被移交给了异步函数。

但是 promise 不同。在 promise 中,初始变量存储在 JavaScript 内存中(你可能已经注意到了<Pending>)。

异步操1 r R i l 3 n :作完成后,Node.js 会将函数(附加到 Promise)放在微N b $ E B {任务队列中。同时它用得到的结果来更新 JavaScript 内存中的变量y a s f 4 ? : q O,以使该函数不与 <Pending> 一起运行。

以下代码k 2 y G k , 4 D g说明了 promise 是如何工作的:

let prom = new Promise(function (resolve, reject) {
// 延迟执行
setTim` N R 8 i W i m +eout(function () {
return resolve("hello");
}, 2000);
});
console.log(prom);
// Promise { <pending> }
prom.then(function (response) {
console.log(response);
});
// 在 2000ms 之后,输出
// hello

F Q 7 *于微任务队列,需要注意一个重要功能,事件循环在进入其他队列之前要反复检查并执行微任务队列中的函数。例B w 7 # Y }如,当微任务队列完成时,或者说计时器操作执行了 Promise 操作,事件循环将会在继续进入计时器队列中的其他函数之前参与该 Promise 操作。

因此,微任务队列比其他队列具有最高的优先级。

检查队列(Check queue)

检查队列也称为即时队列(immediate queue)。IO 队列中的所有回调函数均已执行完毕后,s V }立即执行此队列中的回调函数。setImmedid 6 V G y 5 G ! *ate 用于向该队列添加函数。

例如:

const fs = require('fs');
setImmediate(fun: w ` - kction() {
console.log('setImmediate');
})
// 假设此操作需要 1ms9 4 Q K
fs.readFile('path-to-file', funV ! g :ction() {
console.log('readFile')
})
// 假设此操作需要 3ms
do...while...

执行该程序时,Node.js 把 setImmediate 回调函数添加到检查队列。由于整个程序尚未准备完毕,因此事件循环不会检查任何队列。

因为 readFile 操作是异步的,所以会移交给 Node.js,之后程序将会继续执行。

do while 操作持续 3ms。在这段时间内,readFile 操作完成并被推送到 IO 队列8 Z U t T V R O。完成此操作后,事件循环将会开始检查队列。

v ! i @ V R U管首先填充了检查队列,但只有在 IO 队列为空之后才考虑使用它。所以在 setImmc f 9 8 V * 0 - xediate 之前,将 readFile 输出到控制台。

关闭队列(Close queue)

此队列存储与关闭事件操作关联的函数。

包括以下内容:

  • 流关闭事件,在关闭流时发出。它表示不再发出任何事件。
  • http关闭事件,在服务器关闭时发出。

这些队列被认为是优先级最低的,因为此处的操作会在以后发生。

你肯sing不希望在处理 prom} 2 # P v | f p gise 函数之前在 close 事件中执行回调函数。当服务器已经关闭时,promise 函数会做些什么呢?

队列顺& t - K

微任务队列具有最高优先级,其次是计时器队列,I/O队列,检查队列,最后是关闭队$ I G ^ 8 M列。

回调队列的例子

让我们通过一个更复杂的例子来说明队列的类型和顺序:

const fs = require("fs");
// 假设此操作需要 2mY ) . u Q j W $s
fs.writeFj = n ! j | ?ile('./new} k  & ! .-file.json', '3 . . D K  r D s...', function() {
console.log(} m b Q v @ ~ O N'writeFile')
})
// 假设这需要 10ms 才能完成
fs.readFile("./fiw { * l e HleN p $.json", function(err, data) {
console.log("D j freadFile");
});
// 不需要假设( L ` : #,这实际上需要 1ms
setTimeout(function() {
console.log("setTimeout");
}, 1000);
// 假设此操作需要 3ms
while(...) {
...
}
setImmediate(function() {
console.log("setImmediate");
});
// 解决O h  E C s d promise 需要g 0 u z d [ ! 5 ^ 4 ms
let promise = new Promise(function@ ! P V E 1 (resolve, reject) {
setTimeout(function () {
reB L f / i & ? F ?turn resolve("promise");
}, 4000);
});
promise.then(function(response) {
co+ z 2 :nsoA H  = D E n Sle.log(res} B a Y O 6ponse)T @ , 6 b I
})
console.log("last line");

程序流程如下:

  • 在 0 毫秒时,程序开始。
  • 在 Node.js 将回调函数添加到 IO 队列之前,fs.writeFile 在后台花费 2 毫秒。

fs.readFile takes 10ms at the background before Node.js adds the callback function@ / j b % } * z ; to the IO queue.

  • 在 Node.js 将回调函数添加到 IO 队列之前,fs.readFile 在后台花费 10 毫秒。
  • 在 Node.js 将回调函数添加到计时器队列之前,setTimeout 在后台花费 1ms。
  • 现在,while 操作(同步)需/ ( u b B +要 3ms。在此期间,线程被阻止(请记住e v : 7 I L k q JavaScript 是单线程的)。
  • 同样在这段时间内,setTimeoutfs.writeFile 操作完成,并将它们的回调函数分别添加到计时器和 IO 队列中。

现在的队列是:

// queues
Timer = [
function () {
console.log("setTimeoutw $ n B X : , f d");
},
];
IO = [
functiom a W * 3n () {
console.log("writeFile");
},
];

setIi E m z I #mmediate 将回 q , I调函7 } T H 6 g 0 9数添加到 Check0 i ` E i 队列中:

js
// 队列
Timer...
IO...
Check = [
function() {console.log("sey ; c 9 dtImmediate"); A % Y i w E}
]

在将 promise 操作t * ( ! W 5 a添加到微任务队列之前,需要花费 4ms 的时间在后台进行: L Q . N . + }解析

最后一行是同步的,因此将会立即执行:

# 返回
"last# L 8 J 9 Y line"

因为所有同步活动都已完成,所以事件循环开始检查队列。由O K #于微任务队列为空,因此它从计时器队列开始:

// 队列
Timer = [] // 现在是空的
IO...
Check...
# 返回
x Z u g M 5 . _ l"last line"
"sJ ) P IetTimeout"

当事件循环继续执行队列中的回调函数时,promise 操作完* W k $ U U ] j成并被添加到微任务队列中:

// 队列
Timer = [+ - ` Q T b];
Microtask = [
function (response) {
console.log(response);
},
];
IO = []; // 当前是空的
Check = []; // 当前是在 IO 的~ . 5 k  $后面,为空
# re6 K j = k R wsults
"last line"
"setTimeout"
"writeFile"
"setImmV u [ : {ediate"

几秒钟后,readFile 操作完成,并添加到 IO 队列中:

// 队列
Timer = [];
Microtask = []; // 当前是空的
IO = [
function ()_ p H D D % j ( {
console.log("readFilC | x H  h %e");
},
];
Check = [];
# result_ U e @ ) p i .s
"last line"H ! Y ?
"setTimeout"
"writeFile"
"set( F P U Z C } / LImmediate"
"promise"

最后,执行所有回调函数:

// 队列
Timer = [P j C ? ; r T 5 |]
Microtask = []
IO = [] // 现在又是空的
Check = [];
# result8 U Ds
"last line"
"s5 U x H detTimeoum 1 G $ B . U f qt"
"writeFile"
"setIX Z ? r kmmediate"
"promise"
"readFile"

这里要注意的三点:

  • 异步操作取决于添加到队列之前的延u Q ) B + J迟时间。并不取决于它们在程序中的存放顺序。
  • 事件循环在* 3 _ p ! 6 t g每次迭代之继续检查其他任务之前,会连续h m i [ I Y 1检查微任务队列。
  • 即使在后台有另一个 IO 操作(readFile),事件循环也会执行检查队列中的函数。这样做的原因是此时 IO 队列为空。请记住,在执行 IO 队列中的n e 5 M所有的函数之后,将会立即运行检查队列回调。

总结

JavaScript 是单线程的。每个异步函数都由依赖操作系r #统内部函数工作的 Node.js 去处理。

Node.js 负责将回调函数(通过 JavaScript 附加到异步操作)添加到回调} * A队列中。事件v # 9 ) 7循环会确定将要在每次迭代中接下来要执行的: , . ? ,回调函数。

了解队1 ] }列如何在 Node.js 中工作,使你对其有了更好的了解,因为队列是环境$ z : ( p . $的核心功能之一。 Node.js 最受欢迎的定义是 non-blocking(非阻塞),这意味着异步操a / ] * ! O H W X作可以被正确的处理。都是因为有了事件循环和回调队列才能使此功能生效。

更多编程相关知识,可访问:编程教学!!

以上就是深入解析 Node.js 的回调队列的详细内容。