在先前的章节撰写猜数字程序的时候,我们有先用到 Promise 对象、async 和 await 关键字,如果您不太会 JavaScript 的话,应该会对这些东西非常不熟悉。这个章节将会开始介绍这些东西的用法与演进关系。
首先,也许您已经听过 JavaScript 是单线程的编程语言,即便我们使用 async 关键字来实作异步函数,JavaScript 也还是只会用单线程来运行。
举例来说:
async function infiniteLoop() {
while (1) {
}
}
infiniteLoop();
console.log("Hello!");
以上程序,我们实作了一个 infiniteLoop 异步函数,它的主体就是一个无穷循环。然后在程序第 6 行去调用这个 infiniteLoop 函数,并在其之后尝试输出 Hello! 文字。
然而当我们实际运进程式就会发现,Hello! 文字永远不会出现!这是因为调用异步函数并不等于让 JavaScript 打开一个新的线程来运行它,在 JavaScript 中从头到尾都会使用同一个线程来运行程序。
那么所谓的「异步」函数到底是什么意思,它就跟没有 async 关键字的「同步」函数一样不是吗?要解释这个就得从回呼(callback)函数开始讲起,同时也要对 JavaScript 的「事件循环」(Event Loop)机制有粗略的了解。
事件循环(Event Loop)
事件循环是一个使 JavaScript 得以实现非阻塞 I/O 操作的机制。JavaScript 会将计时器、I/O 操作交由系统内核(system kernel)来处理,使 JavaScript 唯一的线程空闲下来得以运行其它的 JavaScript 程序。
由于大部分的核心是多线程的,所以它可以在背景同时处理多个不同的操作。当内核将一个操作处理完之后,就会替 JavaScript 产生事件,JavaScript 则会依照特定的顺序去「轮询」要运行的「事件」,一个事件的函数运行完之后,才会去运行下一个事件的函数,这样的轮询就是「事件循环」。
不同 JavaScript 运行环境对于事件循环会有不一样的实作方式。
以 Node.js 来说,它在启动的时候,会初始化事件循环,在初始化的过程中会处理用户提供的 JavaScript 程序。运行这份 JavaScript 程序的过程中可能会产生一些要交由系统内核来处理的操作。
在这份 JavaScript 程序运行完后,Node.js 的进程并不会立刻结束运行,而是会进入事件循环,开始轮询系统内核送来的事件。
事件循环大致上可以分为六个阶段,每个阶段都有一个先进先出(FIFO)的队列,来负责保存不同阶段中各自的事件。当一个阶段的队列中的事件全被处理完或者处理完一定数量的事件之后,事件循环就会进入下一个阶段。
以下分别介绍这六个阶段。
第一阶段:计时器(timer)
JavaScript 内置的 setTimeout 和 setInterval 函数可以用来产生计时器相关的事件。
举例来说:
setTimeout(() => {
console.log("Hello");
}, 1000);
当 JavaScript 运行完以上这个程序叙述时,setTimeout 函数会产生一个计时器事件,存到计时器阶段的队列中。而传进 setTimeout 函数第一个参数的匿名函数即为该事件要运行的函数,第二个参数则为这个计时器事件的延期时间(此处为 1000 毫秒,即 1 秒)。当事件循环在轮询的时候,会去看这个计时器事件是否已经到期,到期的话就会立刻运行它,并将它从队列中移出。
setInterval 函数的用法和 setTimeout 一样,如下:
setInterval(() => {
console.log("Hello");
}, 1000);
当 JavaScript 运行完以上这个程序叙述时,setInterval 函数会产生一个计时器事件,存到计时器阶段的队列中。而传进 setInterval 函数第一个参数的匿名函数即为该事件要运行的函数,第二个参数则为这个计时器事件的延期时间(此处为 1000 毫秒,即 1 秒)。当事件循环在轮询的时候,会去看这个计时器事件是否已经到期,到期的话就会立刻运行它,并再重新触发一次这个计时器事件。逻辑有点像是以下这样:
const f = () => {
console.log("Hello");
setTimeout(f, 1000);
};
setTimeout(f, 1000);
虽然 setTimeout 和 setInterval 函数看起来是在控制 JavaScript 在几毫秒之后要去运行某个函数,但 JavaScript 其实并没有办法保证这些函数一定会刚好在指定的时间之后被运行。
当队列中的计时器事件都被检查或是处理过了,就会进入下一个阶段。
第二阶段:pending callbacks
Node.js 提供的文件系统或是网络等 I/O 相关的功能,许多是异步的 API。为了能够让 JavaScript 知道这些异步的 API 的运行状况和结果,我们可以向 Node.js 内部注册回呼函数(callback),作为事件发生时要运行的函数。所谓的「回呼函数」就是专门提供给特定程序在运行时能够传入参数并调用的函数。
许多异步的 API 只会有一种事件,即「运行完毕」的事件。例如删除文件的 API,在尝试删除文件后,就会触发该 API「运行完毕」的事件,将运行结果(包含错误消息)作为回呼函数的参数并运行它。举例来说,以下程序可以删除一个文件,并在主控台上输出 Hello 文字:
import fs = require("node:fs");
fs.unlink(path, (err) => {
if (err) {
console.error(err);
}
});
console.log("Hello");
利用 fs 模块提供的 unlink 函数,可以将第一个参数传入的文件路径对应的文件删除。由于删除文件的动作可能会因为程序没有修改文件系统的权限或是文件根本就不存在而操作失败,所以它可能会回传一个错误消息。以上程序,JavaScript 线程在运行 fs 模块的 unlink 函数之后,删除文件的工作会交由 Node.js 内部和操作系统来处理,JavaScript 不需等到文件删除的动作做完,即可先继续运行之后的程序(也就是在主控台上输出 Hello 文字)。
删除文件的结果,会由 Node.js 内部的程序来监听,一旦删除文件的动作运行完毕,这个「运行完毕」的事件就会被触发,事件的函数就是传进 unlink 函数的第二个参数的回呼函数。事件被触发后,该事件就会被保存在第四阶段,也就是 poll 阶段的队列中。至于这个 pending callbacks 阶段,只会处理少数被延到下一次事件循环迭代才运行的系统操作的回呼函数,例如某些 TCP 连接错误的回呼函数。
第三阶段:idle, prepare
Node.js 内部所使用的阶段。
第四阶段:poll
这个阶段有两个主要的功能:
- 检查其它阶段的队列,看要让 Node.js 在这个阶段待多久。
- 处理在 poll 队列中的事件。
进入这个阶段时若没有计时器的事件,如果这个阶段的队列中有要处理的事件,Node.js 就会依序将它们处理完,或者直到一定数量(数量有多少是系统相依的)的事件被处理完就会直接进入下一次的事件循环迭代;如果 poll 队列中没有要处理的事件,且下一个阶段──check 阶段──有要处理的事件的话,事件循环就会进入下一个阶段;如果 poll 队列中没有要处理的事件,且 check 阶段的队列也没有事件要处理的话,事件循环就会停在这个阶段,会立即对进入这个阶段的事件做出反应。
进入这个阶段时若有计时器的事件,在处理完这个阶段的队列中的所有事件后,会去检查计时器队列是否有到期的事件,如果有的话,事件循环就会回到第一阶段。
有些异步的 API 会有多种事件,而且可能会重复被触发。例如读取文件的串流 API,在向 Node.js 内部注册 data 事件的回呼函数之后,Node.js 内部就会开始读取文件,文件内容并不会一次全被读进内存中,而是会每次在读取一个片段之后,去触发 data 事件,将该段读取到的数据代进回呼函数,然后再继续读取文件。举例来说:
import fs = require("node:fs");
const file = fs.createReadStream("/dev/random");
file.on("data", (chunk) => {
console.log(chunk);
});
console.log("Hello");
fs 模块提供的 createReadStream 函数可以用来创建一个文件读取串流对象,其提供的 on 方法可以用来注册要监听的事件,以及事件发生时要运行的回呼函数,透过这样的方式监听到的事件就会保存到这个阶段的队列中。/dev/random 是 Unix-like 系统下提供的文件,可以用来产生乱数数据。
以上程序,会先在主控台输出 Hello 文字,并在每次 Unix-like 系统产生一段乱数数据后,去触发 data 事件,将随机的数据输出到主控台上。
第五阶段:check
setImmediate 函数所产生的事件可以保证在前一个阶段,也就是 poll 阶段的处理告一段落之后被处理。换句话说,我们可以把比较不重要的工作交由 setImmediate 函数来运行。
需要注意到的地方是,虽然理论上位于第五阶段才被处理的 immediate 事件一定会比位于第一阶段的计时器事件还要来得晚,但实际运行以下程序,会发现 timeout 文字和 immediate 文字的输出顺序并不固定:
setTimeout(() => {
console.log("timeout");
}, 0);
setImmediate(() => {
console.log("immediate");
});
这是因为 0 秒计时器事件当初的创建时间必须要至少与当前时间相差 1 毫秒,才可以被判定为到期。如果 CPU 运行得很快,在第一次事件循环迭代的时候,因计时器事件还没有到期,就会先处理 immediate 事件。如果 JavaScript 线程已经进入事件循环,才去调用 setImmediate 函数和 0 秒的 setTimeout 函数的话,那么 setImmediate 函数一定会比 0 秒的 setTimeout 函数还要早被运行,除非 setImmediate 函数是在接下来要介绍的第六阶段时才被调用。
第六阶段:close callbacks
事件循环的第四阶段,也就是 poll 阶段,并不会处理 I/O 关闭的事件。正常的关闭事件是由等等会提到的 process.nextTick 函数来触发,而像是 Socket 相关的「突发」关闭事件则会在这个阶段才会被处理。
例如:
import net = require("node:net");
const client = new net.Socket();
client.connect(443, "magiclen.org", function () {
console.log("Connected");
client.destroy();
});
client.on("close", function () {
console.log("The close callback is fired.");
});
以上程序,引用了 Node.js 提供的 net 模块,来创建一个 Socket 客户端与本站连接。Socket 连接创建后,当 JavaScript 线程运行到事件循环的第四阶段时,就会输出 Connected 文字到主控台上,并且调用 Socket 客户端对象的 destroy 函数使这个 Socket 连接突然被关闭,来触发 close 事件,将这个事件保存到这个阶段的队列中。当 JavaScript 线程运行到事件循环的第六阶段时,就会处理这个阶段的队列中的所有事件,此时会向主控台输出 The close callback is fired. 文字。
当这个阶段的队列空了,JavaScript 线程就会进入下一个事件循环的迭代。
微任务(Micro Task)和 process.nextTick 函数
JavaScript 的线程在进入一个事件循环阶段时,如果该阶段的队列是空的,或者是每运行完一个事件函数之后,就会去检查当前有没有正在等待中的「微任务」,如果有的话就会先将它们依序运行完。(实际情况会比这边叙述的流程复杂许多,我们只需理解成这样就好了。微任务的产生也可以被视为是一个事件的产生。)我们之前用过的 Promise 对象,就是用来产生微任务的对象。
在这里,我们还要介绍 Node.js 提供的另外一个东西,那就是 process.nextTick 函数。这个函数的用法如下:
process.nextTick(() => {
console.log("Hello");
});
process.nextTick 函数也可以用来添加特殊任务,这类任务的运行时机类似 JavaScript 引擎的微任务,但它们会在微任务之前运行。
以上程序,会创建一个要用来输出 Hello 文字的任务。这个任务的函数(即传进 process.nextTick 函数的第一个参数的函数)会在 JavaScript 线程进入事件循环的时候被运行,然后就会输出 Hello 文字。
回呼(callback)函数
借由 JavaScript 的事件循环机制,以及 JavaScript 的运行环境内部提供的额外线程,使我们可以在单线程的 JavaScript 程序中使用 JavaScript 环境提供的异步功能。透过回呼函数,我们可以控制 JavaScript 在发生某个事件的时候去运行某个特定的函数。
举例来说,如果我们要读取一个文件,计算其 MD5 校验码(checksum)并同时将其写入到另一个文件,比较完整的程序可以这样写:
import fs = require("node:fs");
import crypto = require("node:crypto");
const INPUT_PATH = "input";
const OUTPUT_PATH = "output";
const crypt = crypto.createHash("md5");
const reader = fs.createReadStream(INPUT_PATH);
const writer = fs.createWriteStream(OUTPUT_PATH);
reader.on("data", (chunk) => {
crypt.update(chunk);
writer.write(chunk);
});
reader.on("error", (err) => {
if (err) {
console.error(err);
}
});
reader.on("close", () => {
writer.close();
console.log(`The MD5 checksum is ${crypt.digest().toString("hex")}`);
});
writer.on("close", () => {
console.log("Done!");
});
writer.on("error", (err) => {
if (err) {
console.error(err);
}
});
以上程序,利用 Node.js 内置的 crypto 模块来计算 MD5 哈希值,并在文件读取完毕时,将哈希值(哈希值会用 Node.js 内置的 Buffer 对象来表示)转成 16 进制字符串。fs 模块的 createWriteStream 函数可以创建一个写入串流对象。
对于用 on、addEventListener(用于网页 DOM)等方法来监听某特定名称的事件,回呼函数相当好用。但如果是要调用只会有一种「运行完毕」事件的 API,用回呼函数的方式写起来就会很可怕了。
好比我们想要取得一个文件的信息(文件大小等),并创立一个目录,将这个文件拷贝进新的目录下,然后再把原本的文件删除。程序撰写如下:
import fs = require("node:fs");
import path = require("node:path");
const INPUT_PATH = "input";
const OUTPUT_FOLDER = "folder";
const OUTPUT_NAME = "output";
fs.stat(INPUT_PATH, (err, stats) => {
if (err) {
console.error(err);
return;
}
console.log(stats);
fs.mkdir(OUTPUT_FOLDER, { recursive: true }, (err) => {
if (err) {
console.error(err);
return;
}
const outputPath = path.join(OUTPUT_FOLDER, OUTPUT_NAME);
fs.copyFile(INPUT_PATH, outputPath, (err) => {
if (err) {
console.error(err);
return;
}
fs.unlink(INPUT_PATH, (err) => {
if (err) {
console.error(err);
}
console.log("Done!");
});
});
});
});
以上程序,应用了 Node.js 内置的 path 模块提供的 join 函数来安全地串接路径。
有没有开始觉得回呼函数程序写到后来会愈写愈多层,且愈看愈恶心了?
还好,Node.js 也有提供同步的 API,可以有效改善上面这样难以阅读的代码。套用如下:
import fs = require("node:fs");
import path = require("node:path");
const INPUT_PATH = "input";
const OUTPUT_FOLDER = "folder";
const OUTPUT_NAME = "output";
try {
const stats = fs.statSync(INPUT_PATH);
console.log(stats);
fs.mkdirSync(OUTPUT_FOLDER, { recursive: true });
const outputPath = path.join(OUTPUT_FOLDER, OUTPUT_NAME);
fs.copyFileSync(INPUT_PATH, outputPath);
fs.unlinkSync(INPUT_PATH);
console.log("Done!");
} catch (err) {
console.error(err);
}
只不过用了同步 API,就代表 JavaScript 的线程在运行这些程序的时候,完全无法利用事件循环机制去运行其它地方的代码。如果我们的 JavaScript 程序只是指令工具或是自动调度用途倒还好,但如果是要拿来跑 Web 服务器等服务,或是要用在网页浏览器上,那可就不妙了。在处理一项工作的时候下一个工作会完全进不来,服务或是网页就会像是「冻结」了一样。
所以尽管会让我们的 JavaScript 变得更加复杂,我们在该用异步 API 的时候还是得去用它。还好随着 JavaScript 版本的演进,我们也能写出「看起来同步」的程序语法来使用异步 API。之后的章节会介绍 JavaScript 后来发展出来的 Promise 和「async/await」语法。
