Node.js v21.7.2 文档

术语#

异步资源表示一个与回调关联的对象。此回调可能被多次调用，例如 net.createServer() 中的 'connection' 事件，或者只调用一次，例如 fs.open()。资源也可以在回调被调用之前关闭。AsyncHook 没有明确区分这些不同的情况，但会将它们表示为抽象概念，即资源。

如果使用 Worker，每个线程都有一个独立的 async_hooks 接口，并且每个线程将使用一组新的异步 ID。

概述#

以下是公共 API 的简单概述。

import async_hooks from 'node:async_hooks';

// Return the ID of the current execution context.
const eid = async_hooks.executionAsyncId();

// Return the ID of the handle responsible for triggering the callback of the
// current execution scope to call.
const tid = async_hooks.triggerAsyncId();

// Create a new AsyncHook instance. All of these callbacks are optional.
const asyncHook =
    async_hooks.createHook({ init, before, after, destroy, promiseResolve });

// Allow callbacks of this AsyncHook instance to call. This is not an implicit
// action after running the constructor, and must be explicitly run to begin
// executing callbacks.
asyncHook.enable();

// Disable listening for new asynchronous events.
asyncHook.disable();

//
// The following are the callbacks that can be passed to createHook().
//

// init() is called during object construction. The resource may not have
// completed construction when this callback runs. Therefore, all fields of the
// resource referenced by "asyncId" may not have been populated.
function init(asyncId, type, triggerAsyncId, resource) { }

// before() is called just before the resource's callback is called. It can be
// called 0-N times for handles (such as TCPWrap), and will be called exactly 1
// time for requests (such as FSReqCallback).
function before(asyncId) { }

// after() is called just after the resource's callback has finished.
function after(asyncId) { }

// destroy() is called when the resource is destroyed.
function destroy(asyncId) { }

// promiseResolve() is called only for promise resources, when the
// resolve() function passed to the Promise constructor is invoked
// (either directly or through other means of resolving a promise).
function promiseResolve(asyncId) { }const async_hooks = require('node:async_hooks');

// Return the ID of the current execution context.
const eid = async_hooks.executionAsyncId();

// Return the ID of the handle responsible for triggering the callback of the
// current execution scope to call.
const tid = async_hooks.triggerAsyncId();

// Create a new AsyncHook instance. All of these callbacks are optional.
const asyncHook =
    async_hooks.createHook({ init, before, after, destroy, promiseResolve });

// Allow callbacks of this AsyncHook instance to call. This is not an implicit
// action after running the constructor, and must be explicitly run to begin
// executing callbacks.
asyncHook.enable();

// Disable listening for new asynchronous events.
asyncHook.disable();

//
// The following are the callbacks that can be passed to createHook().
//

// init() is called during object construction. The resource may not have
// completed construction when this callback runs. Therefore, all fields of the
// resource referenced by "asyncId" may not have been populated.
function init(asyncId, type, triggerAsyncId, resource) { }

// before() is called just before the resource's callback is called. It can be
// called 0-N times for handles (such as TCPWrap), and will be called exactly 1
// time for requests (such as FSReqCallback).
function before(asyncId) { }

// after() is called just after the resource's callback has finished.
function after(asyncId) { }

// destroy() is called when the resource is destroyed.
function destroy(asyncId) { }

// promiseResolve() is called only for promise resources, when the
// resolve() function passed to the Promise constructor is invoked
// (either directly or through other means of resolving a promise).
function promiseResolve(asyncId) { }copy

async_hooks.createHook(callbacks)#

• callbacks <Object> 要注册的 钩子回调。
  • init <Function> init 回调。
  • before <Function> before 回调。
  • after <Function> after 回调。
  • destroy <Function> destroy 回调。
  • promiseResolve <Function> promiseResolve 回调。
• 返回值: <AsyncHook> 用于禁用和启用钩子的实例。

注册函数，以便在每个异步操作的不同生命周期事件中调用。

回调 init()/before()/after()/destroy() 在资源生命周期中相应的异步事件期间被调用。

所有回调都是可选的。例如，如果只需要跟踪资源清理，则只需要传递 destroy 回调。可以在 钩子回调 部分找到可以传递给 callbacks 的所有函数的详细信息。

import { createHook } from 'node:async_hooks';

const asyncHook = createHook({
  init(asyncId, type, triggerAsyncId, resource) { },
  destroy(asyncId) { },
});const async_hooks = require('node:async_hooks');

const asyncHook = async_hooks.createHook({
  init(asyncId, type, triggerAsyncId, resource) { },
  destroy(asyncId) { },
});copy

回调将通过原型链继承。

class MyAsyncCallbacks {
  init(asyncId, type, triggerAsyncId, resource) { }
  destroy(asyncId) {}
}

class MyAddedCallbacks extends MyAsyncCallbacks {
  before(asyncId) { }
  after(asyncId) { }
}

const asyncHook = async_hooks.createHook(new MyAddedCallbacks()); copy

由于 Promise 是异步资源，其生命周期通过异步钩子机制跟踪，因此 init()、before()、after() 和 destroy() 回调 *不能* 是返回 Promise 的异步函数。

错误处理#

如果任何 AsyncHook 回调抛出异常，应用程序将打印堆栈跟踪并退出。退出路径遵循未捕获异常的路径，但所有 'uncaughtException' 监听器都将被移除，从而强制进程退出。'exit' 回调仍将被调用，除非应用程序使用 --abort-on-uncaught-exception 运行，在这种情况下，将打印堆栈跟踪，应用程序退出，并留下一个核心文件。

这种错误处理行为的原因是，这些回调函数可能在对象生命周期的不稳定点运行，例如在类构造和析构期间。因此，为了防止将来出现意外中止，有必要快速关闭进程。如果进行全面分析以确保异常可以遵循正常的控制流而不会产生意外的副作用，这将在将来发生变化。

在AsyncHook 回调函数中打印#

由于向控制台打印是异步操作，console.log() 将导致调用AsyncHook 回调函数。在AsyncHook 回调函数内部使用console.log() 或类似的异步操作会导致无限递归。调试时，一个简单的解决方案是使用同步日志记录操作，例如fs.writeFileSync(file, msg, flag)。这将打印到文件，并且不会递归调用AsyncHook，因为它同步。

import { writeFileSync } from 'node:fs';
import { format } from 'node:util';

function debug(...args) {
  // Use a function like this one when debugging inside an AsyncHook callback
  writeFileSync('log.out', `${format(...args)}\n`, { flag: 'a' });
}const fs = require('node:fs');
const util = require('node:util');

function debug(...args) {
  // Use a function like this one when debugging inside an AsyncHook callback
  fs.writeFileSync('log.out', `${util.format(...args)}\n`, { flag: 'a' });
}copy

如果日志记录需要异步操作，可以使用AsyncHook 本身提供的信息来跟踪导致异步操作的原因。然后，当日志记录本身导致调用AsyncHook 回调函数时，应跳过日志记录。通过这样做，可以打破无限递归。

类：AsyncHook#

类AsyncHook 提供了一个接口，用于跟踪异步操作的生命周期事件。

asyncHook.enable()#

• 返回：<AsyncHook> 对asyncHook 的引用。

为给定的AsyncHook 实例启用回调函数。如果没有提供回调函数，则启用将是无操作。

AsyncHook 实例默认情况下是禁用的。如果需要在创建后立即启用 AsyncHook 实例，可以使用以下模式。

import { createHook } from 'node:async_hooks';

const hook = createHook(callbacks).enable();const async_hooks = require('node:async_hooks');

const hook = async_hooks.createHook(callbacks).enable();copy

asyncHook.disable()#

• 返回：<AsyncHook> 对asyncHook 的引用。

从全局 AsyncHook 回调池中禁用给定 AsyncHook 实例的回调。一旦钩子被禁用，它将不会再次被调用，直到被启用。

为了 API 的一致性，disable() 也返回 AsyncHook 实例。

钩子回调#

异步事件生命周期中的关键事件被分为四个区域：实例化、回调调用前后以及实例销毁。

init(asyncId, type, triggerAsyncId, resource)#

• asyncId <number> 异步资源的唯一 ID。
• type <string> 异步资源的类型。
• triggerAsyncId <number> 在其执行上下文中创建此异步资源的异步资源的唯一 ID。
• resource <Object> 代表异步操作的资源的引用，需要在销毁期间释放。

当构造一个可能发出异步事件的类时调用。这并不意味着实例必须在调用 destroy 之前调用 before/after，只是存在这种可能性。

可以通过执行类似于打开资源然后在资源可用之前关闭资源的操作来观察这种行为。以下代码片段演示了这一点。

import { createServer } from 'node:net';

createServer().listen(function() { this.close(); });
// OR
clearTimeout(setTimeout(() => {}, 10));require('node:net').createServer().listen(function() { this.close(); });
// OR
clearTimeout(setTimeout(() => {}, 10));copy

每个新资源都被分配一个在当前 Node.js 实例范围内唯一的 ID。

type#

type 是一个字符串，用于标识导致调用 init 的资源类型。通常，它将对应于资源构造函数的名称。

Node.js 本身创建的资源的 type 可能会在任何 Node.js 版本中发生变化。有效值包括 TLSWRAP、TCPWRAP、TCPSERVERWRAP、GETADDRINFOREQWRAP、FSREQCALLBACK、Microtask 和 Timeout。检查所用 Node.js 版本的源代码以获取完整列表。

此外，AsyncResource 的用户可以创建独立于 Node.js 本身的异步资源。

还有一个 PROMISE 资源类型，用于跟踪 Promise 实例和由它们安排的异步工作。

用户在使用公共嵌入器 API 时可以定义自己的 type。

可能会发生类型名称冲突。鼓励嵌入器使用唯一的前缀（例如 npm 包名称）来防止在监听钩子时发生冲突。

triggerAsyncId#

triggerAsyncId 是导致（或“触发”）新资源初始化并导致 init 调用的资源的 asyncId。这与 async_hooks.executionAsyncId() 不同，后者只显示资源何时创建，而 triggerAsyncId 显示资源创建的原因。

以下是对 triggerAsyncId 的简单演示。

import { createHook, executionAsyncId } from 'node:async_hooks';
import { stdout } from 'node:process';
import net from 'node:net';
import fs from 'node:fs';

createHook({
  init(asyncId, type, triggerAsyncId) {
    const eid = executionAsyncId();
    fs.writeSync(
      stdout.fd,
      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\n`);
  },
}).enable();

net.createServer((conn) => {}).listen(8080);const { createHook, executionAsyncId } = require('node:async_hooks');
const { stdout } = require('node:process');
const net = require('node:net');
const fs = require('node:fs');

createHook({
  init(asyncId, type, triggerAsyncId) {
    const eid = executionAsyncId();
    fs.writeSync(
      stdout.fd,
      `${type}(${asyncId}): trigger: ${triggerAsyncId} execution: ${eid}\n`);
  },
}).enable();

net.createServer((conn) => {}).listen(8080);copy

使用 nc localhost 8080 访问服务器时的输出。

TCPSERVERWRAP(5): trigger: 1 execution: 1
TCPWRAP(7): trigger: 5 execution: 0 copy

TCPSERVERWRAP 是接收连接的服务器。

TCPWRAP 是来自客户端的新连接。当建立新连接时，TCPWrap 实例会立即构造。这发生在任何 JavaScript 堆栈之外。（executionAsyncId() 为 0 表示它正在从 C++ 执行，上面没有 JavaScript 堆栈。）仅凭这些信息，无法将资源链接在一起以了解它们是如何创建的，因此 triggerAsyncId 被赋予了传播哪个资源负责新资源存在的任务。

resource#

resource 是一个对象，它代表已初始化的实际异步资源。访问该对象的 API 可以由资源的创建者指定。由 Node.js 本身创建的资源是内部的，可能会随时更改。因此，这些资源没有指定 API。

在某些情况下，资源对象出于性能原因被重复使用，因此将其用作 WeakMap 中的键或向其添加属性是不安全的。

异步上下文示例#

上下文跟踪用例由稳定 API AsyncLocalStorage 涵盖。此示例仅说明异步钩子操作，但 AsyncLocalStorage 更适合此用例。

以下是一个示例，其中包含有关在 before 和 after 调用之间对 init 的调用的更多信息，特别是 listen() 的回调将是什么样子。输出格式略微复杂，以便更容易地查看调用上下文。

import async_hooks from 'node:async_hooks';
import fs from 'node:fs';
import net from 'node:net';
import { stdout } from 'node:process';
const { fd } = stdout;

let indent = 0;
async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    const eid = async_hooks.executionAsyncId();
    const indentStr = ' '.repeat(indent);
    fs.writeSync(
      fd,
      `${indentStr}${type}(${asyncId}):` +
      ` trigger: ${triggerAsyncId} execution: ${eid}\n`);
  },
  before(asyncId) {
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}before:  ${asyncId}\n`);
    indent += 2;
  },
  after(asyncId) {
    indent -= 2;
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}after:  ${asyncId}\n`);
  },
  destroy(asyncId) {
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}destroy:  ${asyncId}\n`);
  },
}).enable();

net.createServer(() => {}).listen(8080, () => {
  // Let's wait 10ms before logging the server started.
  setTimeout(() => {
    console.log('>>>', async_hooks.executionAsyncId());
  }, 10);
});const async_hooks = require('node:async_hooks');
const fs = require('node:fs');
const net = require('node:net');
const { fd } = process.stdout;

let indent = 0;
async_hooks.createHook({
  init(asyncId, type, triggerAsyncId) {
    const eid = async_hooks.executionAsyncId();
    const indentStr = ' '.repeat(indent);
    fs.writeSync(
      fd,
      `${indentStr}${type}(${asyncId}):` +
      ` trigger: ${triggerAsyncId} execution: ${eid}\n`);
  },
  before(asyncId) {
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}before:  ${asyncId}\n`);
    indent += 2;
  },
  after(asyncId) {
    indent -= 2;
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}after:  ${asyncId}\n`);
  },
  destroy(asyncId) {
    const indentStr = ' '.repeat(indent);
    fs.writeSync(fd, `${indentStr}destroy:  ${asyncId}\n`);
  },
}).enable();

net.createServer(() => {}).listen(8080, () => {
  // Let's wait 10ms before logging the server started.
  setTimeout(() => {
    console.log('>>>', async_hooks.executionAsyncId());
  }, 10);
});copy

仅启动服务器的输出

TCPSERVERWRAP(5): trigger: 1 execution: 1
TickObject(6): trigger: 5 execution: 1
before:  6
  Timeout(7): trigger: 6 execution: 6
after:   6
destroy: 6
before:  7
>>> 7
  TickObject(8): trigger: 7 execution: 7
after:   7
before:  8
after:   8 copy

如示例所示，executionAsyncId() 和 execution 分别指定当前执行上下文的 value；它由对 before 和 after 的调用分隔。

仅使用 execution 来绘制资源分配图，结果如下

  root(1)
     ^
     |
TickObject(6)
     ^
     |
 Timeout(7) copy

TCPSERVERWRAP 不属于此图，即使它是调用 console.log() 的原因。这是因为在没有主机名的情况下绑定到端口是一个同步操作，但为了维护完全异步的 API，用户回调被放置在 process.nextTick() 中。这就是为什么输出中存在 TickObject 并且是 .listen() 回调的“父级”。

该图仅显示资源何时创建，而不是为什么，因此要跟踪为什么，请使用 triggerAsyncId。它可以用以下图表示

 bootstrap(1)
     |
     ˅
TCPSERVERWRAP(5)
     |
     ˅
 TickObject(6)
     |
     ˅
  Timeout(7) copy

before(asyncId)#

• asyncId <number>

当异步操作启动（例如 TCP 服务器接收新连接）或完成（例如将数据写入磁盘）时，会调用回调以通知用户。before 回调在执行所述回调之前立即调用。asyncId 是分配给即将执行回调的资源的唯一标识符。

before 回调将被调用 0 到 N 次。如果异步操作被取消，或者例如 TCP 服务器没有收到任何连接，则 before 回调通常会被调用 0 次。持久性异步资源（如 TCP 服务器）通常会多次调用 before 回调，而其他操作（如 fs.open()）只会调用一次。

after(asyncId)#

• asyncId <number>

在 before 中指定的回调完成之后立即调用。

如果在回调执行期间发生未捕获的异常，则after将在发出'uncaughtException'事件或domain的处理程序运行之后运行。

destroy(asyncId)#

• asyncId <number>

在与asyncId对应的资源被销毁后调用。它也从嵌入器 API emitDestroy() 异步调用。

某些资源依赖于垃圾回收进行清理，因此如果对传递给init的resource对象进行引用，则destroy可能永远不会被调用，从而导致应用程序中的内存泄漏。如果资源不依赖于垃圾回收，则不会出现此问题。

使用 destroy 钩子会导致额外的开销，因为它通过垃圾收集器启用对Promise实例的跟踪。

promiseResolve(asyncId)#

• asyncId <number>

当传递给Promise构造函数的resolve函数被调用时（无论是直接调用还是通过其他方式解析 promise），就会调用它。

resolve()不会执行任何可观察到的同步工作。

如果Promise通过假设另一个Promise的状态来解析，则此时Promise不一定已完成或拒绝。

new Promise((resolve) => resolve(true)).then((a) => {}); copy

调用以下回调

init for PROMISE with id 5, trigger id: 1
  promise resolve 5      # corresponds to resolve(true)
init for PROMISE with id 6, trigger id: 5  # the Promise returned by then()
  before 6               # the then() callback is entered
  promise resolve 6      # the then() callback resolves the promise by returning
  after 6 copy

async_hooks.executionAsyncResource()#

• 返回值：<Object> 代表当前执行的资源。用于在资源中存储数据。

由executionAsyncResource()返回的资源对象通常是具有未记录 API 的内部 Node.js 处理对象。使用对象上的任何函数或属性可能会导致应用程序崩溃，应避免使用。

在顶层执行上下文中使用executionAsyncResource()将返回一个空对象，因为没有可用的句柄或请求对象，但拥有一个代表顶层的对象可能会有所帮助。

import { open } from 'node:fs';
import { executionAsyncId, executionAsyncResource } from 'node:async_hooks';

console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
open(new URL(import.meta.url), 'r', (err, fd) => {
  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
});const { open } = require('node:fs');
const { executionAsyncId, executionAsyncResource } = require('node:async_hooks');

console.log(executionAsyncId(), executionAsyncResource());  // 1 {}
open(__filename, 'r', (err, fd) => {
  console.log(executionAsyncId(), executionAsyncResource());  // 7 FSReqWrap
});copy

这可以用于实现延续本地存储，而无需使用跟踪Map来存储元数据

import { createServer } from 'node:http';
import {
  executionAsyncId,
  executionAsyncResource,
  createHook,
} from 'async_hooks';
const sym = Symbol('state'); // Private symbol to avoid pollution

createHook({
  init(asyncId, type, triggerAsyncId, resource) {
    const cr = executionAsyncResource();
    if (cr) {
      resource[sym] = cr[sym];
    }
  },
}).enable();

const server = createServer((req, res) => {
  executionAsyncResource()[sym] = { state: req.url };
  setTimeout(function() {
    res.end(JSON.stringify(executionAsyncResource()[sym]));
  }, 100);
}).listen(3000);const { createServer } = require('node:http');
const {
  executionAsyncId,
  executionAsyncResource,
  createHook,
} = require('node:async_hooks');
const sym = Symbol('state'); // Private symbol to avoid pollution

createHook({
  init(asyncId, type, triggerAsyncId, resource) {
    const cr = executionAsyncResource();
    if (cr) {
      resource[sym] = cr[sym];
    }
  },
}).enable();

const server = createServer((req, res) => {
  executionAsyncResource()[sym] = { state: req.url };
  setTimeout(function() {
    res.end(JSON.stringify(executionAsyncResource()[sym]));
  }, 100);
}).listen(3000);copy

async_hooks.executionAsyncId()#

• 返回值：<number> 当前执行上下文的 asyncId。用于跟踪何时调用。

import { executionAsyncId } from 'node:async_hooks';
import fs from 'node:fs';

console.log(executionAsyncId());  // 1 - bootstrap
const path = '.';
fs.open(path, 'r', (err, fd) => {
  console.log(executionAsyncId());  // 6 - open()
});const async_hooks = require('node:async_hooks');
const fs = require('node:fs');

console.log(async_hooks.executionAsyncId());  // 1 - bootstrap
const path = '.';
fs.open(path, 'r', (err, fd) => {
  console.log(async_hooks.executionAsyncId());  // 6 - open()
});copy

从 executionAsyncId() 返回的 ID 与执行时间相关，而不是因果关系（因果关系由 triggerAsyncId() 涵盖）。

const server = net.createServer((conn) => {
  // Returns the ID of the server, not of the new connection, because the
  // callback runs in the execution scope of the server's MakeCallback().
  async_hooks.executionAsyncId();

}).listen(port, () => {
  // Returns the ID of a TickObject (process.nextTick()) because all
  // callbacks passed to .listen() are wrapped in a nextTick().
  async_hooks.executionAsyncId();
}); copy

默认情况下，Promise 上下文可能无法获得精确的 executionAsyncIds。请参阅有关 Promise 执行跟踪 的部分。

async_hooks.triggerAsyncId()#

• 返回值：<number> 负责调用当前正在执行的回调的资源的 ID。

const server = net.createServer((conn) => {
  // The resource that caused (or triggered) this callback to be called
  // was that of the new connection. Thus the return value of triggerAsyncId()
  // is the asyncId of "conn".
  async_hooks.triggerAsyncId();

}).listen(port, () => {
  // Even though all callbacks passed to .listen() are wrapped in a nextTick()
  // the callback itself exists because the call to the server's .listen()
  // was made. So the return value would be the ID of the server.
  async_hooks.triggerAsyncId();
}); copy

默认情况下，Promise 上下文可能无法获得有效的 triggerAsyncId。请参阅有关 Promise 执行跟踪 的部分。

async_hooks.asyncWrapProviders#

• 返回值：提供程序类型到相应数字 ID 的映射。此映射包含 async_hooks.init() 事件可能发出的所有事件类型。

此功能抑制了对 process.binding('async_wrap').Providers 的弃用用法。请参阅：DEP0111

Promise 执行跟踪#

默认情况下，Promise 执行不会分配 asyncId，因为 V8 提供的 Promise 自省 API 相对昂贵。这意味着默认情况下，使用 Promise 或 async/await 的程序将不会获得 Promise 回调上下文的正确执行和触发 ID。

import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';

Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 1 tid 0const { executionAsyncId, triggerAsyncId } = require('node:async_hooks');

Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 1 tid 0copy

请注意，then() 回调声称在外部范围的上下文中执行，即使涉及异步跳转。此外，triggerAsyncId 值为 0，这意味着我们缺少有关导致（触发）then() 回调执行的资源的上下文。

通过 async_hooks.createHook 安装异步钩子可以启用 Promise 执行跟踪。

import { createHook, executionAsyncId, triggerAsyncId } from 'node:async_hooks';
createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.
Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 7 tid 6const { createHook, executionAsyncId, triggerAsyncId } = require('node:async_hooks');

createHook({ init() {} }).enable(); // forces PromiseHooks to be enabled.
Promise.resolve(1729).then(() => {
  console.log(`eid ${executionAsyncId()} tid ${triggerAsyncId()}`);
});
// produces:
// eid 7 tid 6copy

在此示例中，添加任何实际的钩子函数都启用了 Promise 的跟踪。上面的示例中有两个 Promise；由 Promise.resolve() 创建的 Promise 和由对 then() 的调用返回的 Promise。在上面的示例中，第一个 Promise 获取了 asyncId 6，而第二个 Promise 获取了 asyncId 7。在执行 then() 回调期间，我们在 asyncId 为 7 的 Promise 的上下文中执行。此 Promise 由异步资源 6 触发。

关于 Promise 的另一个细微之处是，before 和 after 回调函数只在链式 Promise 上运行。这意味着不是由 then()/catch() 创建的 Promise 不会触发 before 和 after 回调函数。有关更多详细信息，请参阅 V8 PromiseHooks API 的详细信息。

JavaScript 嵌入器 API#

处理自身异步资源的库开发者（执行诸如 I/O、连接池或管理回调队列等任务）可以使用 AsyncResource JavaScript API，以便调用所有适当的回调函数。

类：AsyncResource#

此类的文档已移至 AsyncResource。

类：AsyncLocalStorage#

此类的文档已移至 AsyncLocalStorage。