V8虚拟机事件循环机制(NodeJS)

1 消息队列

1.1 回调函数

回调函数区别于普通函数,在于它的调用方式:只有当某个函数被作为参数,传递给另外一个函数,或者传递给宿主环境,然后该函数在函数内部或者在宿主环境中被调用,我们才称为回调函数。

回调函数有两种不同的形式:同步回调和异步回调。

1.2 同步回调

当函数被当做回调函数传给myArray.forEach时,会立即执行handlerArray(indexName,index)这个函数,示例代码如下:

  • 调用 forEach 时,需要使用回调函数 handlerArray 作为其参数;
  • 在 forEach 方法内部,会遍历 myArray 数组,每遍历一次都会调用一次回调函数 handlerArray;
▼
javascript
复制代码
var myArray = ["water", "goods", "123", "like"]; function handlerArray(indexName,index){ console.log(index + 1 + ". " + indexName); } myArray.forEach(handlerArray)

1.3 异步回调

当执行到setTimeout()时,此时会立即返回,但并不执行foo()函数,直到3s后开始执行,代码如下:

▼
javascript
复制代码
function foo() { alert("Hello"); } setTimeout(foo, 3000)

异步代码的执行需要了解 V8 在运行时的线程模型,涉及到了消息队列,事件循环等概念,这些概念都和线程模型是直接相关。

1.4 UI线程架构(浏览器)

:::success 由于宿主环境的不同,因此浏览器中V8的事件循环和Node.js服务器中的事件循环不同。仅仅做为对比了解。

:::

当V8的宿主环境是浏览器时候,主线程为UI线程。UI 线程,是指运行窗口的线程,当运行一个窗口时,无论该页面是 Windows 上的窗口系统,还是 Android 或者 iOS 上的窗口系统,它们都需要处理各种事件,诸如有触发绘制页面的事件,有鼠标点击、拖拽、放大缩小的事件,有资源下载、文件读写的事件,等等。

但由于窗口上事件会被频繁出发,例如:滚动事件,当滚动时候就会触发,用户使用时会连续进行滚动,而如果每次等待滚动事件触发并执行完毕后再同步执行另一个滚动事件,那么会造成浏览器的卡顿,因此UI线程提供了一个消息队列,将触发的事件放入到消息队列中,并循环监听消息队列中的事件,当事件执行完成后,再执行消息队列中的回调函数。

例如:

  1. 有一个按钮,点击后会从服务器下载文件,此时当用户点击时,该事件会被封装成任务放入消息队列中;
  2. 线程会从消息队列中取出一个任务,并分析该任务。
  3. 分析过程中发现该任务是一个下载请求,那么主线程(这里指UI线程)就会将该任务交给网络线程去执行。
  4. 网络线程接到请求之后,便会和服务器端建立连接,并发出下载请求;
  5. 网络线程不断地收到服务器端传过来的数据;
  6. 网络线程每次接收到数据时,都会将设置的回调函数和返回的数据信息,如大小、返回了多少字节、返回的数据在内存中存放的位置等信息封装成一个新的事件,并将该事件放到消息队列中 ;
  7. UI 线程继续循环地读取消息队列中的事件,如果是下载状态的事件,那么 UI 线程会执行回调函数,程序员便可以在回调函数内部编写更新下载进度的状态的代码;
  8. 直到最后接收到下载结束事件,程序员可以在下载结束事件时候编写代码通知用户;

2 Node.js事件循环架构

:::success Node.js是V8的一个宿主环境,了解Node.js的事件循环架构及流程,需要对其宿主环境有所了解,因为Node.js事件循环不仅仅用到V8中提供的消息队列,还用到了Node.js提供的nextTick队列和微任务队列,且涉及到Node.js服务器中如libuv模块的执行和调用。

快照机制

事件循环在进入每个阶段时,会先获取该阶段当前的队列快照,然后执行快照中的所有回调。在执行过程中新加入的回调,不会被当前轮次处理,必须等到下一轮循环。

:::

2.1 Node.js架构总览

Node.js最经典架构如下图所示:

在 Node.js 架构中,不同的模块扮演着不同的角色,各自有着特定的作用。以下是 Node.js 架构中一些核心模块的主要作用:

  1. 核心模块(Core Modules):核心模块是 Node.js 内置的模块,可以直接使用而无需安装。例如,fs 模块用于文件系统操作,http 模块用于创建 HTTP 服务器,path 模块用于处理文件路径等。核心模块提供了许多基本的功能和 API,支持底层的系统操作。
  2. 模块管理器(Module System):Node.js 使用模块管理器来组织和加载模块。模块管理器允许将相关的代码封装为一个模块,并通过 require 函数进行加载和引用。模块管理器支持模块的导入、导出以及模块之间的依赖关系管理,使得开发者能够更好地组织和维护代码。
  3. 网络模块(Net/HTTP/DNS 模块):Node.js 提供了一系列的网络模块,用于处理与网络通信相关的任务。其中,net 模块用于创建 TCP 服务器和客户端,http 模块用于创建 HTTP 服务器和客户端,dns 模块用于进行 DNS 查询等。这些网络模块使得 Node.js 能够轻松地构建网络应用程序。
  4. 异步 I/O 模型(Event-driven I/O):Node.js 使用基于事件驱动的异步 I/O 模型,利用事件循环机制来处理非阻塞的 I/O 操作。这样可以提高并发性能,充分利用系统资源。通过回调函数或 Promise 等机制,开发者可以编写非阻塞、高效的异步代码。
  5. 缓冲区模块(Buffer 模块):Buffer 模块用于处理二进制数据,提供了创建、读取、写入和转换二进制数据的方法。它是处理流数据、网络数据以及文件系统操作中常用的模块。
  6. 事件模块(EventEmitter 模块):EventEmitter 模块是 Node.js 中用于实现事件驱动的机制。它允许开发者在程序中定义自定义事件,并触发和监听这些事件。通过事件模块,可以实现模块之间的解耦和代码的灵活性。

除了以上列举的核心模块外,还有其他一些模块,如 crypto(加密和解密),util(实用工具函数),os(操作系统相关信息),stream(流处理)等,它们都有着各自特定的作用和功能。I

2.2 事件循环过程中涉及的组件

:::success 事件循环并不是严格按照下面图片的流程来执行的,下面图片中的队列由上向下实际是队列的优先级顺序,当所有队列都有任务时候,会按照该优先级顺序来执行。

:::

processon

**Node.js服务器:**由各个组件组成,其架构如2.1中所展示,但在事件循环流程中,主要使用到libuv库、nextTick队列、微任务队列、V8虚拟机等,各个组件作用如下:

  • **V8虚拟机:**V8虚拟机有许多结构,例如执行栈、堆、解释器、垃圾回收器等组件。涉及到事件循环流程的组件是调用栈。
    • **调用栈:**可以看作主线程的执行栈,每次V8从事件循环的队列中拉取任务到调用栈中,交给V8主线程进行执行。
    • **堆:**栈中引用的对象实际存储位置,栈中只存储指针。
  • **libuv组件(库):**主要负责 是一个跨平台的异步 I/O 库,它在 Node.js 中起着关键的作用,例如:异步I/O、事件循环、线程池管理、定时器、事件处理等。
    • **线程池:**libuv 通过线程池来执行一些耗时的操作,如文件 I/O、DNS 解析等。它管理这些工作线程的创建和销毁,并将具体任务分配到不同的线程中执行,以保证主线程的响应性和吞吐量。
    • timers队列: 此阶段执行由 setTimeout() 和 setInterval() 排序。
    • pending callbacks队列: 执行 I/O 回调因异常或延迟而推迟到下一个循环迭代的任务。
    • idle回调, prepare回调:在 libuv 中,只能注册一个 idle() 回调函数和一个prepare()回调函数。这些回调函数会在特定的事件循环阶段触发执行。idle() 回调函数会在事件循环的空闲阶段执行,而 prepare() 回调函数会在进入下一个事件循环阶段之前执行。
    • I/O polling队列: 该队列实际上会具有两个操作,当事件循环的control处在该阶段时候,会首先尝试从队列中取出已经完成I/O操作的回调任务并交给V8执行,但是当当前队列执行为空或本来就处于空状态时候,此时control会尝试从libuv的线程池中poll已经完成的任务(线程池不会主动推),若不存在已经完成的I/O任务,则control会在该位置处于一种持续监听状态,直到等待一个完成的I/O事件出现,并将其回调任务放入I/O队列,然后执行check队列阶段。
    • check队列: setImmediate() 回调在此处被调用。
    • close callbacks队列:一些关闭的回调函数,如:socket.on('close', ...)。
  • **微任务队列:**微任务队列并非libuv提供,而是由nodejs服务器提供。
    • nextTick队列: 在 Node.js 中,process.nextTick() 方法将回调函数添加到 nextTick 队列中。在事件循环的当前阶段结束后、下一个阶段开始前执行。
    • Promise队列: 主要用于执行相对较轻量级的回调函数,例如 Promise 的 then 方法中的回调,确保它们在尽可能快的时间内得到执行。微任务队列可以在同一事件循环中立即执行,而不需要等待下一个事件循环。

3 事件循环的执行

:::success V8会优先执行完主线程执行栈中的代码,再从事件循环中拉取任务。按照阶段划分,事件循环按照以下阶段来进行:

  1. 微任务阶段:首先执行nextTick队列中的回调,然后执行Promise队列中的回调;
  2. 执行idle函数和prepare函数;
  3. timers阶段:执行timers队列中的一个回调;
  4. 微任务阶段:首先执行nextTick队列中的回调,然后执行Promise队列中的回调;
  5. pending callbacks阶段:处理上一轮循环未执行的 I/O 回调,例如网络、I/O 等异常时的回调;
  6. 微任务阶段:首先执行nextTick队列中的回调,然后执行Promise队列中的回调;
  7. I/O Polling阶段:首先会尝试从I/O队列中拿回调函数并执行,如果I/O队列为空,会进入polling流程,既事件循环的control(控制器)会尝试从线程池中拿去已经执行完成的I/O任务,并其回调放入到I/O队列中(线程池无法主动推送完成的任务给I/O队列),如果检查没有已经完成的I/O任务,那么control会进入一个监听状态,等待直到有一个I/O任务完成,并将其放入I/O队列中;
  8. 微任务阶段:首先执行nextTick队列中的回调,然后执行Promise队列中的回调;
  9. Check阶段:执行setImmediate(()=>{})的一个回调函数
  10. 微任务阶段:首先执行nextTick队列中的回调,然后执行Promise队列中的回调;
  11. close阶段:执行例如readableStream.on("close", () => {});等流式资源关闭close相关回调函数;
  12. 重复执行1阶段 开启下一次循环;

:::

3.1 微任务队列(nextTick/Promise)

3.1.1 示例代码1

▼
javascript
复制代码
// index.js console.log("console.log 1"); process.nextTick(() => console.log("this is process.nextTick 1")); console.log("console.log 2");

执行流程

此处为语雀卡片,点击链接查看

  1. 首先执行同步代码console.log("console.log 1");,直接输出console.log 1;
  2. 然后执行process.nextTick(() => console.log("this is process.nextTick 1"));,将回调函数() => console.log("this is process.nextTick 1")封装成任务放入nextTick队列中;
  3. 继续执行同步代码console.log("console.log 2");,直接输出console.log 2;
  4. 同步代码执行完毕,开启事件循环,从nextTick队列中取出任务() => console.log("this is process.nextTick 1"))并执行;
  5. 输出this is process.nextTick 1

3.1.2 示例代码2

▼
javascript
复制代码
// index.js Promise.resolve().then(() => console.log("this is Promise.resolve 1")); process.nextTick(() => console.log("this is process.nextTick 1"));

执行流程

此处为语雀卡片,点击链接查看

  1. 当执行Promise.resolve().then(() => console.log("this is Promise.resolve 1"));时候,将回调函数() => console.log("this is Promise.resolve 1")放入Promise队列中;
  2. 当执行process.nextTick(() => console.log("this is process.nextTick 1"));时候,将回调函数() => console.log("this is process.nextTick 1")放入到nextTick队列中;
  3. 同步代码执行完毕,开启事件循环,首先从微任务队列中取出回调函数,微任务队列中,nextTick优先级大于Promise队列,因此先执行() => console.log("this is process.nextTick 1"),执行完毕后输出this is process.nextTick 1;
  4. 当nextTick队列执行完毕后,事件循环的control(控制器)向下推进,开始执行Promise队列中的任务() => console.log("this is Promise.resolve 1")被执行,输出this is Promise.resolve 1;

3.1.3 示例代码3

▼
javascript
复制代码
// index.js process.nextTick(() => console.log("this is process.nextTick 1")); process.nextTick(() => { console.log("this is process.nextTick 2"); process.nextTick(() => console.log("this is the inner next tick inside next tick") ); }); process.nextTick(() => console.log("this is process.nextTick 3")); Promise.resolve().then(() => console.log("this is Promise.resolve 1")); Promise.resolve().then(() => { console.log("this is Promise.resolve 2"); process.nextTick(() => console.log("this is the inner next tick inside Promise then block") ); }); Promise.resolve().then(() => console.log("this is Promise.resolve 3"));

执行流程

此处为语雀卡片,点击链接查看

  1. 先执行同步代码,将() => console.log("this is process.nextTick 1")回调函数放入到nextTick队列中;
  2. 继续执行同步代码,将以下代码放入到nextTick队列中,目前队列中有两个回调函数
▼
javascript
复制代码
() => { console.log("this is process.nextTick 2"); process.nextTick(() => console.log("this is the inner next tick inside next tick") ); }
  1. 继续执行同步代码将() => console.log("this is process.nextTick 3")回调函数放入nextTick队列中;
  2. 同理继续执行,将Promise中的回调按照执行顺序放入到Promise队列中;
  3. 同步任务执行完毕,此时开始事件循环,首先从优先级更高的nextTick队列中按照顺序取出回调函数并执行,执行后输出this is process.nextTick 1;
  4. 然后取出回调2中的代码并执行,输出this is process.nextTick 2,然后将() => console.log("this is the inner next tick inside next tick") );放入nextTick队列中,此时nextTick队列中新增了一个回调函数;
  5. 继续从nextTick队列中取出第三个回调函数并执行,输出"this is process.nextTick 3";
  6. 继续从nextTick队列中取出回调2放入nextTick的回调函数,输出this is the inner next tick inside next tick;
  7. 此时nextTick队列已经不存在回调函数,向下推进事件循环,开始从Promise队列中取出任务并执行,直到该队列为空,依次打印:this is Promise.resolve 1``this is Promise.resolve 2``this is Promise.resolve 3``this is the inner next tick inside Promise then block

3.2 pedding calls队列

该队列不方便使用代码模拟,pedding calls执行的任务是上一次循环中出现延迟或推迟的回调函数。目前针对该队列的资料比较少,nodejs官网说明该队列在timers阶段之前被执行,但是也有不少资料说明该队列在timers阶段后执行,其执行顺序仍存疑,这里采纳官网的说法。Node.js 事件循环,定时器和 process.nextTick() | Node.js

3.3 timers队列

3.3.1 示例代码1

▼
javascript
复制代码
// index.js setTimeout(() => console.log("this is setTimeout 1"), 0); setTimeout(() => console.log("this is setTimeout 2"), 0); setTimeout(() => console.log("this is setTimeout 3"), 0); process.nextTick(() => console.log("this is process.nextTick 1")); process.nextTick(() => { console.log("this is process.nextTick 2"); process.nextTick(() => console.log("this is the inner next tick inside next tick") ); }); process.nextTick(() => console.log("this is process.nextTick 3")); Promise.resolve().then(() => console.log("this is Promise.resolve 1")); Promise.resolve().then(() => { console.log("this is Promise.resolve 2"); process.nextTick(() => console.log("this is the inner next tick inside Promise then block") ); }); Promise.resolve().then(() => console.log("this is Promise.resolve 3"));

执行流程

  1. 执行第一个setTimeout(()=>{...}),V8将任务交给libuv,libuv开启新的线程并通过调用操作系统的API来实现定时任务;
  2. 执行第二个setTimeout(()=>{...}),同1;
  3. 执行第三个setTimeout(()=>{...}),同1;
  4. 执行第一个nextTick(()=>{...}),将回调函数放入微任务队列的nextTick队列中;
  5. 执行第二个nextTick(()=>{...}),同4;
  6. 执行第二个nextTick(()=>{...}),同4;
  7. 执行第一个Promise.resolve().then(() =>{..}),将回调函数放入微任务队列的Promise队列中;
  8. 执行第二个Promise.resolve().then(() =>{..}),同7;
  9. 执行第三个Promise.resolve().then(() =>{..}),同7;
  10. 执行栈中任务执行完毕,开启事件循环,首先从微任务队列的nextTick队列中取出回调函数,执行第一个回调函数,输出“this is process.nextTick 1”,当前nextTick队列还剩下2个任务;
  11. 从微任务队列的nextTick队列中取出回调函数,执行第二个回调函数,输出“this is process.nextTick 2”,然后将新的回调函数放入到nextTick队列中,当前nextTick队列还剩下2个任务;
  12. 执行第三个nextTick的回调函数,输出"this is process.nextTick 3";
  13. 执行第四个nextTick的回调函数,输出"this is the inner next tick inside next tick";
  14. nextTick队列执行完毕,事件循环开始执行微任务队列Promise队列中的任务;
  15. 同理依次输出:"this is Promise.resolve 1"、"this is Promise.resolve 2"、"this is Promise.resolve 3"、"this is the inner next tick inside Promise then block"
  16. Promise队列执行完毕,由于setTimeout的时间设置为0,但是实际上受到操作系统定时任务的影响,大概会有个位数量级的延迟(1-2ms),此时setTimeout执行完毕,libuv将回调函数放回到timers队列中;
  17. V8开始执行timers队列中的任务,由于定时任务已经完成,此时timers队列中有任务,所以依次拿出任务并开始执行,依次输出"this is setTimeout 1"、"this is setTimeout 2"、"this is setTimeout 3";

3.3.2 示例代码2

▼
javascript
复制代码
// index.js setTimeout(() => console.log("this is setTimeout 1"), 0); setTimeout(() => { console.log("this is setTimeout 2"); process.nextTick(() => console.log("this is inner nextTick inside setTimeout") ); }, 0); setTimeout(() => console.log("this is setTimeout 3"), 0);

执行流程

  1. 执行第一个setTimeout(()=>{...}),V8将任务交给libuv,libuv开启新的线程并通过调用操作系统的API来执行定时任务;
  2. 执行第二个setTimeout(()=>{...}),同1;
  3. 执行第三个setTimeout(()=>{...}),同1
  4. 由于设置时间为0ms,但实际上不可能做到0ms,会有短暂延迟,此时操作系统所有定时任务执行完毕,通知libuv将回调放到timers队列中;
  5. 事件循环开启,依次检查nextTick队列、Promise队列中不存在任务,直到执行到timers队列中,拿出第一个回调函数放到执行栈中执行,输出"this is setTimeout 1";
  6. 本次timers任务执行完毕后,再检查微任务队列(分别检测nextTick和Promise队列)中没有任务,于是继续执行timers队列,拿出第二个回到函数并执行,输出"this is setTimeout 2",然后将新的回调函数放入到nextTick队列中;
  7. 本次timers任务执行完毕,再检查微任务队列,此时nextTick队列中有任务,于是拿出来任务并执行,输出"this is inner nextTick inside setTimeout";
  8. 继续执行第三个setTimeout(()=>{...}),输出"this is setTimeout 3";

3.3.3 示例代码3

▼
javascript
复制代码
// index.js setTimeout(() => console.log("this is setTimeout 1"), 1000); setTimeout(() => console.log("this is setTimeout 2"), 500); setTimeout(() => console.log("this is setTimeout 3"), 0);

执行流程

  1. 开始执行代码,将setTimeout交给libuv执行,libuv调用操作系统提供的定时任务回调;
  2. 同步代码执行完毕,此时过去了大概2ms,第三个setTimeout执行完毕,libuv将回到函数放入timers队列中,此时开启事件循环后发现timers队列中有任务,取出任务并执行,输出"this is setTimeout 3";
  3. 此时继续向下推进事件循环,发现tiemrs队列为空,进入I/O队列中,I/O队列为空,此时不会继续向下执行事件循环,而是在I/O队列中进入一种监听状态;
  4. 此时经过了500ms,libuv将第二个回调回到函数放入timers队列中,此时control监听到timers队列中有任务重新开启事件循环,输出"this is setTimeout 2";
  5. 执行完毕后,control发现tiemrs队列为空,进入I/O队列中,I/O队列为空,此时不会继续向下执行事件循环,而是在I/O队列中进入一种监听状态;
  6. 此时经过了1000ms,libuv将第三个回调回到函数放入timers队列中,此时control监听到timers队列中有任务重新开启事件循环,输出"this is setTimeout 3";

3.4 I/O poll队列

3.4.1 代码示例1

▼
javascript
复制代码
// index.js const fs = require("fs"); fs.readFile(__filename, () => { console.log("this is readFile 1"); }); process.nextTick(() => console.log("this is process.nextTick 1")); Promise.resolve().then(() => console.log("this is Promise.resolve 1")); setTimeout(() => console.log("this is setTimeout 1"), 0); for (let i = 0; i < 2000000000; i++) {}

执行流程

  1. 当执行fs.readFile()时,V8会任务异步给libuv执行,libuv开启新的线程来执行I/O任务;
  2. 当执行process.nextTick()时,V8将回调函数放入nextTick队列中;
  3. 当执行Promise时候,V8将回到函数放入Promise队列;
  4. 继续执行setTimeout(),V8异步交给libuv执行;
  5. 继续执行for循环,在for循环执行完毕后,I/O已经执行完毕,setTimeout也执行完毕,此时回调会被放入到对应的事件循环队列中(实际上I/O任务回调并不是直接由libuv放入事件循环队列,而是会经历一个poll的过程,这里为了简化直接被放如了I/O队列中)
  6. 开启事件循环,依次执行nextTick队列、Promise队列、timers队列、I/O队列,输出结果;

3.5 check队列

3.5.1 示例代码1

▼
javascript
复制代码
// index.js const fs = require("fs"); fs.readFile(__filename, () => { console.log("this is readFile 1"); }); process.nextTick(() => console.log("this is process.nextTick 1")); Promise.resolve().then(() => console.log("this is Promise.resolve 1")); setTimeout(() => console.log("this is setTimeout 1"), 0); setImmediate(() => console.log("this is setImmediate 1")); for (let i = 0; i < 2000000000; i++) {}

执行流程

  1. 当执行fs.readFile()时,V8会任务异步给libuv执行,libuv开启新的线程来执行I/O任务;
  2. 当执行process.nextTick()时,V8将回调函数放入nextTick队列中;
  3. 当执行Promise时候,V8将回到函数放入Promise队列;
  4. 继续执行setTimeout(),V8异步交给libuv执行;
  5. 继续执行setImmediate(),V8将其交给libuv执行;
  6. 此时执行栈为空,开启事件循环,首先按照顺序执行nextTick、Promise、timers的任务;
  7. 当执行I/O队列时,此时I/O任务已经完成,但是I/O队列仍然为空。这是因为I/O队列区别与其他队列,libuv并不会直接将完成的任务拉取到I/O队列中。而是由control首先对I/O队列进行检查,若此时队列为空,control会执行一个poll过程,该过程会尝试从libuv中查找已经完成的I/O任务,并将其回调拉取到I/O队列中,如果没有则进入一个监听的状态,等待一个事件触发,或操作系统通知有I/O任务执行完毕。而当一个完成的I/O任务被拉取到I/O队列时候,此时由于control已经执行过I/O队列的检查,并不会立即执行I/O队列的回调函数,而是继续事件循环,执行check队列中的任务回调,直到下次control循环到I/O队列才会执行回调函数;
  8. 执行 console.log("this is setImmediate 1"));输出结果,check队列执行完毕后,继续按照微任务队列、timers队列从头开始事件循环;
  9. 此时再执行I/O队列时候,发现I/O队列中有任务存在,立即执行并输出结果;

3.6 close队列

3.6.1 示例代码

▼
javascript
复制代码
// index.js const fs = require("fs"); const readableStream = fs.createReadStream(__filename); readableStream.close(); readableStream.on("close", () => { console.log("this is from readableStream close event callback"); }); setImmediate(() => console.log("this is setImmediate 1")); setTimeout(() => console.log("this is setTimeout 1"), 0); Promise.resolve().then(() => console.log("this is Promise.resolve 1")); process.nextTick(() => console.log("this is process.nextTick 1"));
  1. 当执行readableStream.on("close",()=>{})时,V8会任务异步给libuv执行;
  2. 继续执行setTimeout(),V8异步交给libuv执行;
  3. 继续执行setImmediate(),V8将其交给libuv执行;
  4. 当执行process.nextTick()时,V8将回调函数放入nextTick队列中;
  5. 当执行Promise时候,V8将回到函数放入Promise队列;
  6. 执行栈同步代码执行完毕,开启事件循环,依次执行nextTick队列、Promise队列、timers队列、I/O队列、check队列、close队列,输出结果。
0个评论
点击登录,快来和大家讨论吧~
表情
图片
暂无评论
慕士塔格
下载 APP