w wyl123ly 的博客
MD

JavaScript-04-异步编程

52 KB 2026.10.11 原文件

JavaScript-04-异步编程

这篇讲什么

JavaScript 是单线程的,却要同时处理网络请求、定时器、用户点击——靠的就是事件循环(Event Loop)。

本篇从「为什么需要异步」出发,完整拆解事件循环的执行顺序,再依次讲透回调、Promise、async/await 三代异步写法,

最后给出并发控制、取消请求与反模式清单。读完你应该能准确预测任意一段异步代码的输出顺序。


一、是什么

异步编程(Asynchronous Programming) 指的是:发起一个耗时操作后不等待它完成,先继续执行后面的代码;

等操作完成时,再通过回调、Promise 或 await 的恢复机制回来处理结果。

与之相对的是同步(Synchronous)代码:一行执行完才走下一行,耗时操作会把整条执行线索「卡住」。

用一个生活中的比喻:

模型类比后果
同步阻塞点外卖后站在店门口等,直到做好才回家这一小时什么都做不了
异步回调点完外卖留下电话,回家干别的事电话响了再去取,时间被复用

JavaScript 的异步不是靠多线程,而是靠事件循环在单线程上把「等待时间」复用起来。

这是它与 C# 的 Task、Python 的 asyncio 在实现层面最大的差别:

后两者语言本身支持多线程/协程调度,而 JS 的宿主环境(浏览器、Node.js)只有一条执行 JS 的主线程。

二、为什么这样设计

2.1 单线程:历史的选择,也是必然

JS 诞生于浏览器,最初的职责是操作 DOM。如果允许两条线程同时改同一个 DOM 节点,

就必须引入锁(Lock)来保证一致性——而这会让一门给网页写脚本的语言变得极其笨重。

// 假设 JS 是多线程的,下面这段代码根本无法定义「正确答案」
// 线程 A: title.textContent = '你好';
// 线程 B: title.remove();
// 此刻 title 到底是「有文字的新节点」还是「已被删除」?

于是设计者做了一个取舍:只有一条线程可以执行 JS 代码,耗时操作交给宿主环境(浏览器/Node.js)去后台做,

做完之后把回调「排队」回主线程。这条主线就是事件循环。

2.2 阻塞(Blocking)的代价

「单线程」意味着任何一段同步代码都会独占主线程。耗时计算、同步 I/O、甚至一个写错的死循环,

都会让页面失去响应。下面这段代码可以在 Chrome DevTools 控制台里直接粘贴运行:

// 运行环境:Chrome / Edge DevTools 控制台(或任何浏览器控制台)
console.time('sync');
// Atomics.wait 是少数能在浏览器主线程里制造「真同步等待」的方式
try {
  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000); // 阻塞 2 秒
} catch (e) {
  // 部分浏览器主线程禁止 Atomics.wait,退化说明即可
  const end = Date.now() + 2000;
  while (Date.now() < end) { /* 忙等待同样会卡住主线程 */ }
}
console.timeEnd('sync'); // sync: 2000ms 左右
console.log('主线程在这 2 秒里无法响应任何点击、无法渲染任何界面');

核心结论

阻塞主线程 = 页面冻结。时间复杂度的直觉在这里要换成「墙钟时间(Wall-clock Time)」的直觉:

一个 的同步循环放大到 时,用户看到的就是「页面未响应」。

异步的意义不是让计算变快,而是不占用主线程。

2.3 为什么不用「多开线程」解决

浏览器确实提供了 Web Worker 与 Node.js 提供了 Worker Threads,但它们:

  • 运行在独立的执行环境,没有 DOM 访问权(Worker 里改不了页面);
  • 与主线程只能通过消息(postMessage)通信,数据需要结构化克隆(Structured Clone),有序列化开销;
  • 每个 Worker 有自己的事件循环,调试与状态同步成本高。

所以日常业务代码的异步,仍然是基于事件循环的协作式调度,而不是把工作拆到多个线程。

三、核心内容

3.1 事件循环的完整机制

先建立四个角色的心智模型:

角色存放什么谁往里放
调用栈(Call Stack)当前正在执行的函数帧JS 引擎
宏任务队列(Macrotask Queue)整段 script、setTimeout/setInterval 回调、I/O 回调、UI 事件回调宿主环境
微任务队列(Microtask Queue)Promise 的 then/catch/finally 回调、queueMicrotask 回调、await 恢复JS 引擎自身
渲染步骤(Rendering)样式计算、布局、绘制浏览器,在两次任务之间择机执行

一次循环的算法(简化版,完整规范见 HTML Standard 的 event loop processing model):

1. 从宏任务队列中取出「最早入队」的一个任务,执行它,直到调用栈清空
2. 清空微任务队列:只要队列非空,就取出最早的一个执行
   —— 注意:微任务执行过程中新产生的微任务,也在本轮被清空
3. 如果浏览器判断需要渲染,就执行渲染(样式 → 布局 → 绘制)
4. 若宏任务队列为空,休眠等待新任务到来;否则回到第 1 步

把这段流程画成时序:

flowchart LR
    A["取一个宏任务"] --> B["执行到调用栈清空"]
    B --> C{"微任务队列非空?"}
    C -- 是 --> D["执行最早的微任务"] --> C
    C -- 否 --> E["渲染(需要时)"]
    E --> A

两条必须记住的规则:

  1. 每个宏任务执行完后,会立刻清空整个微任务队列,然后才可能渲染、才可能执行下一个宏任务。
  2. 微任务之间不会插入渲染,也不会插入 UI 事件。所以微任务里写死循环 = 页面直接卡死,连「未响应」提示都可能出不来。
用一段代码验证执行顺序
// 运行环境:任意浏览器的 DevTools 控制台
console.log('script start');                       // ① 同步

setTimeout(() => console.log('setTimeout'), 0);    // 宏任务,入队

Promise.resolve()
  .then(() => console.log('promise 1'))            // 微任务
  .then(() => console.log('promise 2'));           // 微任务(由上一个 then 产生)

queueMicrotask(() => console.log('queueMicrotask')); // 微任务

console.log('script end');                         // ② 同步

// 输出顺序:
// script start
// script end
// promise 1
// queueMicrotask
// promise 2
// setTimeout

解释:同步代码 ①② 先跑完;随后清空微任务队列。promise 1 与 queueMicrotask 在同一个宏任务里注册,

按注册顺序执行;promise 2 是在 promise 1 的 then 回调执行时才被注册进微任务队列的,

所以排在 queueMicrotask 后面。setTimeout 的回调要等整个微任务队列清空后的下一个宏任务。

渲染发生在什么时候

浏览器不会「定时」渲染,而是按屏幕刷新率(通常是 60Hz → 约 16.7ms 一次)判断是否有渲染时机(Rendering Opportunity)。

渲染插在微任务清空之后、下一个宏任务之前。因此:

// 运行环境:浏览器页面中(写在 <script> 里,或控制台但需先有 #box)
const box = document.createElement('div');
box.id = 'box';
document.body.append(box);

box.style.width = '100px';
Promise.resolve().then(() => {
  // 微任务里读到的仍是「已更新但尚未绘制」的值 —— 会触发强制同步布局
  console.log(getComputedStyle(box).width); // "100px"
  box.style.width = '200px';
});
// 用户最终只会看到 200px:两次修改发生在同一次渲染之前,第一次被「合并」掉了

这解释了为什么「改三次样式」不会闪三下——渲染是批量的,而强制读取布局(offsetWidth、getComputedStyle)会打断批量,

这也是 前端-04-浏览器与HTTP 里「重排(Reflow)」话题的根源。

setTimeout 的最小延迟:为什么 setTimeout(fn, 0) 不立即执行

三个原因叠加:

原因说明
它本来就是宏任务即使延迟为 0,回调也必须排队等当前宏任务 + 所有微任务全部结束
规范规定的最小延迟HTML 规范要求:当嵌套层级(Nesting Level)大于 5 时,最小延迟被钳制为 4ms(见 MDN setTimeout)
浏览器内部节流后台标签页、省电模式下延迟会被进一步拉大(可能变成 1000ms 级别)
// 运行环境:浏览器 DevTools 控制台
let last = Date.now();
let depth = 0;

function tick() {
  const now = Date.now();
  console.log(`第 ${depth} 层嵌套,间隔 ${now - last}ms`);
  last = now;
  if (++depth <= 8) setTimeout(tick, 0);
}
last = Date.now();
tick();
// 前几次约 0~1ms,从第 6 层起稳定在 4ms 左右 —— 这就是「嵌套 4ms 钳制」

这带来的实际影响:用 setTimeout(fn, 0) 把大任务切片执行时,

调度要放在任务开头,否则每次都要白白等 4ms 以上(zh.javascript.info 的事件循环章节专门讨论了这个优化)。

想「尽快、但在当前任务之后」执行,用微任务

queueMicrotask(fn) 或 Promise.resolve().then(fn) 会在当前宏任务结束后、渲染之前执行,

没有 4ms 钳制,也不会有定时器精度问题。代价是它会阻塞渲染,不能用来做长耗时任务。

3.2 浏览器与 Node.js 事件循环的差异

Node.js 的 libuv 把事件循环拆成了明确的阶段(Phases),这是与浏览器最大的不同。

flowchart TD
    T["timers 阶段<br/>setTimeout / setInterval 到期回调"] --> P["pending callbacks<br/>上一轮延迟的 I/O 回调"]
    P --> PO["poll 阶段<br/>等待并执行 I/O 回调(如 fs、net)"]
    PO --> C["check 阶段<br/>setImmediate 回调"]
    C --> CL["close callbacks<br/>socket.on('close') 等"]
    CL --> T
    N["process.nextTick 队列<br/>每个阶段切换时先清空它,再清空微任务"] -.-> T
对比项浏览器Node.js
队列划分宏任务队列 + 微任务队列(较简单)六个阶段,每个阶段有各自的回调队列
微任务队列Promise 回调、queueMicrotask同上,且每个阶段之间都会清空微任务队列
专属高优先级队列无process.nextTick 队列:在回调内部注册时优先于 Promise 回调
定时器与 I/O 的相对顺序由入队顺序决定,较直观受 poll 阶段耗时影响,setTimeout(fn,0) 与 setImmediate 顺序可能不确定
渲染有(渲染时机)无渲染概念
事件循环结束条件页面关闭没有待处理的任务/句柄时进程退出
// 运行环境:Node.js 20 LTS 及以上,`node nexttick-demo.mjs`
// 关键:把两者注册在「同一个定时器回调内部」,才能看出 nextTick 的优先级
setTimeout(() => {
  Promise.resolve().then(() => console.log('1 promise  (先注册)'));
  process.nextTick(() => console.log('2 nextTick (后注册,却先执行)'));
}, 0);

setImmediate(() => console.log('3 setImmediate (check 阶段)'));
console.log('0 同步代码');

// 输出顺序:
// 0 同步代码
// 2 nextTick (后注册,却先执行)
// 1 promise  (先注册)
// 3 setImmediate (check 阶段)

顶层注册时顺序会反过来,别被绕晕

实测(Node.js 24)结果:

| 注册位置 | 观察到的顺序 |

|---|---|

| 模块顶层 | 顶层代码被当作一个「微任务检查点」,nextTick 队列与 Promise 微任务按注册顺序执行 |

| setTimeout / I/O 回调内部 | 无论注册顺序,nextTick 队列都先于 Promise 微任务清空 |

所以「nextTick 优先于 Promise」这条经验法则只在回调内部成立。

记住结论即可:回调内部要「插队」,用 process.nextTick;否则用 queueMicrotask。

process.nextTick 是把双刃剑

它的命名有误导性——它不是「下一个 tick 执行」,而是「当前操作结束后立即执行,且优先于所有微任务」。

如果在 nextTick 回调里递归调用 nextTick,事件循环会被永久饿死(Starvation),I/O 与定时器永远得不到执行。

Node.js 官方文档现在建议:能用 queueMicrotask() 就不要用 process.nextTick()(见 Node.js process 文档

的 "When to use queueMicrotask() vs. process.nextTick()")。nextTick 目前主要用于兼容历史 API 的内部实现。

3.3 第一代写法:回调函数(Callback)

回调函数(Callback Function):把「稍后要执行的逻辑」作为参数传给异步 API。

// 运行环境:浏览器 DevTools 控制台(XMLHttpRequest 浏览器、Node 18+ 都支持)
const xhr = new XMLHttpRequest();
xhr.open('GET', 'https://example.com/api/user/1');
xhr.onload = () => console.log(xhr.responseText);
xhr.onerror = () => console.error('请求失败');
xhr.send();

单个回调很清晰。问题出在依赖串联:后一步需要前一步的结果,于是回调层层嵌套。

回调地狱(Callback Hell):三层嵌套读文件

下面这个例子模拟「读取用户配置 → 根据配置读取数据文件 → 再写入日志」的真实需求:

// 运行环境:Node.js 18+,`node callback-hell.mjs`
import { readFile, writeFile } from 'node:fs';

// 需求:读 config.json → 读它指定的 dataFile → 把内容追加进 log.txt
readFile('config.json', 'utf8', (err1, config) => {
  if (err1) {
    console.error('读取配置失败:', err1);
    return;                                  // ← 必须手动 return,否则会继续往下跑
  }

  readFile(JSON.parse(config).dataFile, 'utf8', (err2, data) => {
    if (err2) {
      console.error('读取数据失败:', err2);
      return;                                // ← 又一次重复的错误处理
    }

    writeFile('log.txt', data + '\n', { flag: 'a' }, (err3) => {
      if (err3) {
        console.error('写日志失败:', err3);
        return;                              // ← 第三次
      }
      console.log('全部完成');
    });
  });
});

痛点一:可读性崩塌。 控制流是「向右再向下」的锯齿(俗称 Pyramid of Doom)。

三层还能忍,真实项目里五层很常见,缩进直接吃掉半屏宽度。

痛点二:错误处理无法复用。 每个回调都要重复一遍 if (err),

而且必须记得 return——忘了写就会在出错后继续执行下一步,产生更隐蔽的 bug。

更糟的是,任何一步的 throw 都不会被外层的 try/catch 捕获:

// 运行环境:Node.js 18+
try {
  setTimeout(() => {
    throw new Error('回调里的错误');
  }, 0);
} catch (e) {
  // 永远不会执行!异常发生时,try 块早就出栈了
  console.error('捕获到:', e.message);
}
// 实际结果:进程因未捕获异常而崩溃(Node)或控制台报 Uncaught Error(浏览器)

原因:try/catch 依赖调用栈,而异步回调执行时调用栈里早已没有引发它的那个 try。

这是「错误处理」维度的根本缺陷,也是 Promise 被发明出来的直接动机。

痛点三:无法组合。 想「三个请求都完成后统一处理」或「只要最快的一个」,

用回调实现需要自己维护计数器与状态标志,极易写错。

3.4 第二代写法:Promise

三态与不可逆性

Promise 是一个状态机,只有三种状态:

状态含义能否再变
pending(待定)初始状态,尚未有结果可以变为 fulfilled 或 rejected
fulfilled(已兑现)成功,带一个 value不可再变
rejected(已拒绝)失败,带一个 reason(通常是 Error)不可再变

一旦落定(settled,即离开 pending),状态与值都被永久冻结,后续的 resolve/reject 调用一律被忽略:

// 运行环境:任意浏览器 DevTools 控制台
const p = new Promise((resolve, reject) => {
  resolve('第一次调用生效');
  resolve('第二次被忽略');
  reject(new Error('这个 reject 也会被忽略'));
});

p.then(v => console.log('fulfilled:', v)); // fulfilled: 第一次调用生效
p.catch(e => console.log('rejected:', e.message)); // 不会执行

一个容易混淆的细节:resolve 一个 Promise 会「跟随」它

resolve(thenable) 中的 thenable 如果是一个 Promise,那么 p 会等待它,

而不是立刻 fulfilled。见下一节的「不能 resolve 自己」。

then / catch / finally 的返回值与链式调用

这是 Promise 最核心的规则:这三个方法永远返回一个「新的」 Promise,

新 Promise 的状态由回调的返回值决定。

回调中的行为新 Promise 的结果
return valuefulfilled,值为 value
不写 return(返回 undefined)fulfilled,值为 undefined
return Promise等待这个 Promise 落定,采用它的状态与值
throw errrejected,reason 为 err
回调本身不存在(如只写了 .then(onFulfilled) 却发生了拒绝)状态与值原样透传给下一个
// 运行环境:任意浏览器 DevTools 控制台
Promise.resolve(1)
  .then(v => {
    console.log('收到', v);
    return v + 1;            // 返回值 → 下一个 then 收到 2
  })
  .then(v => {
    throw new Error(`在 ${v} 处出错`); // 抛出 → 进入后面的 catch
  })
  .then(() => console.log('不会执行'))  // 被跳过
  .catch(e => {
    console.log('捕获:', e.message);   // 捕获:在 2 处出错
    return 'recovered';                 // catch 也能「恢复」链条
  })
  .finally(() => console.log('finally 不接收参数,也不改变结果'))
  .then(v => console.log('最终值:', v)); // 最终值: recovered

finally 的三个特性(MDN):不接收任何参数;不改变链条的值或拒绝原因(原样透传);

但如果它抛错或返回一个 rejected 的 Promise,则会覆盖原来的结果。

错误穿透(Error Propagation)

链条上任意一环抛错或返回被拒绝的 Promise,都会跳过后面所有没有 onRejected 的 then,

直到遇到第一个 catch(或带第二个参数的 then)。这就是错误穿透:

// 运行环境:浏览器 DevTools 控制台
const steps = [];
Promise.resolve('a')
  .then(v => { steps.push('step1'); return v; })
  .then(() => { steps.push('step2'); throw new Error('boom'); })
  .then(() => { steps.push('step3(被跳过)'); })
  .then(() => { steps.push('step4(被跳过)'); })
  .catch(e => { steps.push('catch: ' + e.message); })
  .then(() => console.log(steps.join(' → ')));
// step1 → step2 → catch: boom

实践建议:把 .catch 放在链尾

一个链条只在末尾写一个 catch,就能覆盖前面所有环节的错误——这是回调风格永远做不到的。

中间步骤若需要「失败后降级继续」,再单独在那一环加 catch 并返回兜底值。

静态方法四件套对比
方法何时落定成功结果失败行为典型场景
Promise.all全部 fulfilled结果数组,顺序与输入一致任意一个 rejected 立刻整体 rejected(其余结果被忽略,但不会取消)多接口数据必须齐全才能渲染
Promise.allSettled全部 settled{status:'fulfilled', value} / {status:'rejected', reason} 数组,从不 rejected无(永远 fulfilled)批量上传、逐个展示成功/失败
Promise.race第一个 settled(成功或失败都算)第一个落定者的值第一个落定者若是失败,则整体失败超时竞速:race([请求, 超时])
Promise.any第一个 fulfilled第一个成功的值全部失败时以 AggregateError 拒绝,其 errors 属性含所有原因多镜像源取最快可用的一个
// 运行环境:Node.js 18+(原生 fetch 需要 Node 18 及以上),`node promise-combos.mjs`
const ok = (v, ms) => new Promise(r => setTimeout(() => r(v), ms));
const bad = (msg, ms) => new Promise((_, rj) => setTimeout(() => rj(new Error(msg)), ms));

// 1) all:一荣俱荣 —— 结果顺序按输入,不按完成时间
console.log(await Promise.all([ok('慢', 100), ok('快', 10)])); // [ '慢', '快' ]

// 2) allSettled:永不失败,适合「逐个展示」
console.log(await Promise.allSettled([ok(1, 10), bad('坏了', 20)]));
// [ { status: 'fulfilled', value: 1 }, { status: 'rejected', reason: Error: 坏了 } ]

// 3) race:第一个落定者说了算 —— 常用作超时
const timeout = (ms) => new Promise((_, rj) => setTimeout(() => rj(new Error('超时')), ms));
try {
  await Promise.race([ok('数据', 500), timeout(100)]);
} catch (e) {
  console.log('race 失败:', e.message); // race 失败: 超时
}

// 4) any:只认第一个成功者
console.log(await Promise.any([bad('镜像1挂了', 10), ok('镜像2可用', 50)])); // 镜像2可用

// 5) any 全部失败:AggregateError
try {
  await Promise.any([bad('a', 10), bad('b', 20)]);
} catch (e) {
  console.log(e.constructor.name, e.errors.map(x => x.message)); // AggregateError [ 'a', 'b' ]
}
手写一个简易 Promise:理解原理

自己实现一遍,三件事就彻底清楚了:executor 同步执行、状态机不可逆、then 回调走微任务。

// 运行环境:Node.js 18+ 或浏览器控制台,`node my-promise.mjs`
const PENDING = 'pending', FULFILLED = 'fulfilled', REJECTED = 'rejected';

class MyPromise {
  #state = PENDING;      // 状态机
  #value;                // 成功值
  #reason;               // 失败原因
  #onFulfilledCbs = [];  // pending 期间注册的成功回调
  #onRejectedCbs = [];   // pending 期间注册的失败回调

  constructor(executor) {
    // executor 由 new 时立即同步执行 —— 这就是「Promise 一经创建就已开始」的原因
    const resolve = (value) => this.#settle(FULFILLED, value);
    const reject = (reason) => this.#settle(REJECTED, reason);
    try {
      executor(resolve, reject);
    } catch (err) {
      reject(err); // executor 内部同步抛错 → 变成 rejected
    }
  }

  #settle(state, payload) {
    if (this.#state !== PENDING) return;  // 不可逆:已落定则忽略后续调用
    // resolve(thenable) 要「跟随」它(真实规范里的 Promise Resolution Procedure 会递归处理)
    if (state === FULFILLED && payload && typeof payload.then === 'function') {
      payload.then(
        (v) => this.#settle(FULFILLED, v),
        (r) => this.#settle(REJECTED, r),
      );
      return;
    }
    this.#state = state;
    if (state === FULFILLED) this.#value = payload;
    else this.#reason = payload;
    // 落定后统一调度已注册的回调
    queueMicrotask(() => {
      const cbs = state === FULFILLED ? this.#onFulfilledCbs : this.#onRejectedCbs;
      cbs.forEach((cb) => cb(payload));
    });
  }

  then(onFulfilled, onRejected) {
    // then 必须返回「新的」Promise,链式调用才有意义
    return new MyPromise((resolve, reject) => {
      const handle = (cb, fallback, payload) => {
        if (typeof cb !== 'function') return fallback(payload); // 穿透:非函数则原样传递
        try {
          resolve(cb(payload));  // 回调返回值决定新 Promise(若为 Promise 会被跟随)
        } catch (err) {
          reject(err);           // 回调抛错 → 新 Promise rejected
        }
      };

      // 关键:用 queueMicrotask 保证回调异步执行,而不是同步立刻执行
      queueMicrotask(() => {
        if (this.#state === FULFILLED) {
          handle(onFulfilled, resolve, this.#value);
        } else if (this.#state === REJECTED) {
          handle(onRejected, reject, this.#reason);
        } else {
          // 还没落定:先把回调挂起来,等 settle 时再统一调度
          this.#onFulfilledCbs.push((v) =>
            handle(onFulfilled, resolve, v));
          this.#onRejectedCbs.push((r) =>
            handle(onRejected, reject, r));
        }
      });
    });
  }

  catch(onRejected) {
    return this.then(undefined, onRejected); // catch 就是只有失败回调的 then
  }

  finally(onFinally) {
    // 不接收参数、不改变结果;若自身抛错则覆盖结果
    return this.then(
      (v) => MyPromise.resolve(onFinally()).then(() => v),
      (r) => MyPromise.resolve(onFinally()).then(() => { throw r; }),
    );
  }

  static resolve(value) {
    return value instanceof MyPromise ? value : new MyPromise((r) => r(value));
  }
}

// —— 验证 ——
const order = [];
new MyPromise((resolve) => {
  order.push('executor 同步执行');
  resolve(1);
}).then((v) => order.push('then 收到 ' + v));

order.push('then 之后的同步代码');
setTimeout(() => console.log(order.join(' → ')), 0);
// executor 同步执行 → then 之后的同步代码 → then 收到 1

真实规范比这复杂

ECMAScript 规范里还有 PromiseResolveThenableJob、NewPromiseResolveThenableJob、

以及「thenable 只允许被调用一次」等细节(见 tc39.es/ecma262 的 Control Abstraction Objects 章节)。

上面这份实现足够解释行为,但不含 Promise.all 等静态方法,也不处理循环引用(resolve 自己)。

不能 resolve 自己
// 运行环境:浏览器控制台
const p = new Promise((resolve) => setTimeout(() => resolve(p), 0));
p.catch(e => console.log(e.constructor.name)); // TypeError: Chaining cycle detected

3.5 第三代写法:async / await

async/await 是基于 Promise 的语法糖,本质没变——只是把「回调注册」写成了看似同步的样子。

语法与返回值包装
// 运行环境:Node.js 18+,`node async-basics.mjs`
async function f1() { return 1; }                    // 返回值被包装成 Promise
async function f2() { return Promise.resolve(2); }   // 返回 Promise 会被「跟随」并解包
async function f3() { throw new Error('boom'); }     // 抛错变成 rejected

console.log(f1());                                   // Promise { 1 }
console.log(await f1());                             // 1
console.log(await f2());                             // 2(不是 Promise<Promise<2>>)
await f3().catch(e => console.log(e.message));       // boom

关键点:async 函数永远返回 Promise。所以调用方要么 await,要么 .then,不存在「直接拿到值」的可能。

await 之后代码进入微任务

await 会暂停当前函数,把「后续代码」注册为微任务,然后立刻把控制权还给调用者。

用一段代码就能看出这一点:

// 运行环境:浏览器 DevTools 控制台
async function demo() {
  console.log('1 async 开始');
  await null;                       // 即使 await 一个非 Promise,也会让出一次微任务
  console.log('3 await 之后');      // 这里是微任务
}

demo();
console.log('2 同步代码');
// 1 async 开始 → 2 同步代码 → 3 await 之后

为什么 await null 也会让出

await 的语义是「把后续代码挂到该值的 Promise 落定之后」。

实现上会走 Promise.resolve(value).then(continuation),因此即使值已就绪,continuation 也必须排进微任务队列,

而不是同步继续。这与 then 的行为完全一致(见 tc39.es/ecma262 中 Await 抽象操作)。

用 try/catch 捕获异步错误

这是 await 相对回调最大的工程收益:异步错误可以像同步错误一样被 try/catch 捕获。

// 运行环境:Node.js 18+,`node try-catch-await.mjs`
async function fetchUser(id) {
  try {
    const res = await fetch(`https://example.com/api/users/${id}`);
    if (!res.ok) throw new Error(`HTTP ${res.status}`);  // fetch 不会因 4xx/5xx 而 reject!
    return await res.json();
  } catch (err) {
    console.error('统一处理:', err.message);
    return null;   // 降级:让调用方拿到 null 而不是崩溃
  }
}

fetch 的「假成功」

fetch 只在网络层面失败(断网、DNS 失败、被 CORS 拦截)时 reject。

服务器返回 500、404 时,Promise 依然是 fulfilled,必须手动检查 res.ok 或 res.status。

这是新手最常踩的坑之一。另外 res.json() 也要 await——返回的是 Promise。

在循环中使用 await 的串行陷阱
// 运行环境:Node.js 18+,`node loop-await.mjs`
const ids = [1, 2, 3, 4, 5];
const request = (id) => new Promise(r => setTimeout(() => r({ id }), 300)); // 每个耗时 300ms

// ❌ 写法 A:串行 —— 总耗时 ≈ 5 × 300 = 1500ms
let t = Date.now();
const a = [];
for (const id of ids) {
  a.push(await request(id));   // 每次都在等上一个完成
}
console.log(`串行耗时 ${Date.now() - t}ms`);   // ≈1500ms

// ✅ 写法 B:并行 —— 总耗时 ≈ 300ms
t = Date.now();
const b = await Promise.all(ids.map((id) => request(id)));  // 先全部发起,再统一等待
console.log(`并行耗时 ${Date.now() - t}ms`);   // ≈300ms

用公式描述:设单个任务耗时 ,并发度为 ,则

什么时候必须串行? 后一步依赖前一步的结果时。例如「创建订单 → 用订单 ID 发起支付」。

但仅仅是「循环遍历」并不构成依赖,要主动检查是不是可以改成 Promise.all。

for await...of 语法本身也是串行的(每轮 await 一次),它适用于异步可迭代对象

(如逐块读取的流),而不是用来「并行遍历数组」:

// 运行环境:Node.js 18+,`node for-await.mjs`
// 逐个读取数组中的异步任务结果(串行)
async function* gen() {
  yield await Promise.resolve('A');
  yield await Promise.resolve('B');
}
for await (const v of gen()) console.log(v);   // A  B

// 真实场景:逐块消费可读流,避免把整个文件读进内存
// import { createReadStream } from 'node:fs';
// for await (const chunk of createReadStream('big.log')) { /* 处理 chunk */ }

数组是同步可迭代的,for await 用在数组上也能跑,但每轮都是串行

如果目标只是「并行跑完一个数组」,用 Promise.all(ids.map(...)),

不要用 for await,否则白白串行化。

并发控制:手写 pLimit

Promise.all 会一次性发起所有请求。1000 个请求同时打出去,轻则把接口打挂,

重则触发浏览器对同域名连接数的限制(HTTP/1.1 下通常 6 个)反而更慢。

这时需要限制并发度。下面是一个可直接使用的最小实现:

// 运行环境:Node.js 18+,`node plimit.mjs`
// 也可直接放进浏览器页面/模块中使用
function pLimit(concurrency) {
  if (!Number.isInteger(concurrency) || concurrency < 1) {
    throw new RangeError('concurrency 必须是 >= 1 的整数');
  }

  const queue = [];        // 等待执行的任务
  let activeCount = 0;     // 正在执行的任务数

  const next = () => {
    activeCount--;
    if (queue.length > 0) queue.shift()();   // 有空位就唤醒队首任务
  };

  const run = async (fn, resolve, reject) => {
    activeCount++;
    try {
      resolve(await fn());     // 用 await 保证同步抛错也被捕获
    } catch (err) {
      reject(err);
    } finally {
      next();                  // 无论成功失败都要释放名额
    }
  };

  return (fn) =>
    new Promise((resolve, reject) => {
      // 队列里放的是「启动这个任务」的闭包,而不是任务本身
      queue.push(() => run(fn, resolve, reject));
      if (activeCount < concurrency) queue.shift()();
    });
}

// —— 使用:100 个任务,最多同时跑 5 个 ——
const limit = pLimit(5);
let running = 0, peak = 0;
const task = (n) => limit(async () => {
  running++; peak = Math.max(peak, running);
  await new Promise(r => setTimeout(r, 50));
  running--;
  return n * 2;
});

const results = await Promise.all(
  Array.from({ length: 100 }, (_, i) => task(i)),
);
console.log('结果条数:', results.length, '峰值并发:', peak); // 100 峰值并发: 5

实现要点:

  1. 队列存的是闭包,真正的任务要等到有名额时才执行——若直接 queue.push(fn),任务一进来就跑了。
  2. finally 里释放名额,否则一个任务失败就会永久占位,队列卡死。
  3. limit() 返回 Promise,所以外面仍可以用 Promise.all 统一等待——并发度与「全部完成」两件事被解耦。
AbortController 取消请求

Promise 本身没有取消机制(这是它被长期批评的设计缺陷)。

取消要由发起方提供:fetch 等 Web API 接受一个 signal 参数。

// 运行环境:浏览器页面 / DevTools 控制台(Node.js 18+ 也支持 fetch + AbortController)
const controller = new AbortController();
const { signal } = controller;

// 场景 1:用户点「取消」
document.querySelector('#cancelBtn')?.addEventListener('click', () => controller.abort());

// 场景 2:超时自动取消
const timeoutId = setTimeout(() => controller.abort(new Error('请求超时')), 3000);

try {
  const res = await fetch('https://example.com/api/slow', { signal });
  console.log(await res.json());
} catch (err) {
  if (err.name === 'AbortError') {
    console.warn('请求已被取消');
  } else {
    console.error('其他错误:', err.message);
  }
} finally {
  clearTimeout(timeoutId);   // 成功也要清掉定时器,避免无谓的 abort
}

关于「超时」的现代写法

新版本运行环境提供 AbortSignal.timeout(ms) 与 AbortSignal.any([...]) 组合多个信号,

用它们比手写 Promise.race 超时干净得多。可用性以 MDN AbortSignal 页面与目标浏览器版本为准。

需要同时兼容旧环境时,Promise.race([请求, timeout]) 仍然有效——但它只是放弃等待,请求仍在后台继续,

真正的取消只有 signal 能做到。

3.6 常见反模式清单

反模式问题正确做法
async 函数里忘记 await错误不会被 try/catch 捕获,变成「未处理的拒绝」每个返回 Promise 的调用都 await 或用 .catch 兜底
await 写在 forEach 里forEach 不等待异步回调,循环结束就返回了用 for...of 串行,或 Promise.all(arr.map(...)) 并行
循环里逐个 await无依赖却串行,耗时线性叠加确认无依赖后改 Promise.all
.then 里 return promise 却忘了链式返回外层拿到的是 undefined,时序错乱return 出来,或直接用 await
new Promise 包一层已经返回 Promise 的 API冗余且容易丢错误(Promise 构造器反模式)直接 return fetch(...)
在 Promise 构造器里 async executorexecutor 里的 await 抛错无法被 catch 到executor 保持同步,只在里面调 resolve/reject
只写 try 不写 catch 就 await错误冒泡成 unhandledRejection(Node 默认会终止进程)显式 catch,或注册全局 unhandledRejection 处理器记录日志
用 setTimeout(fn, 0) 做「立刻执行」至少 0~4ms 延迟,还排在所有微任务后面用 queueMicrotask(fn)
递归 process.nextTick事件循环饥饿,I/O 永远不执行改用 queueMicrotask 或 setImmediate
Promise.all 里混入可能失败的非关键任务一个失败导致整体失败,其他成功结果全丢关键用 all,非关键用 allSettled

未处理的拒绝(Unhandled Rejection)

在 Node.js 中,一个既没有 catch、也没有全局处理器的 Promise 拒绝会导致进程退出(默认

--unhandled-rejections=throw,见 Node.js process 文档的 'unhandledRejection' 事件)。

生产环境应当在进程入口注册处理器,把原因记入日志,而不是靠它来「恢复运行」。


四、怎么用:一个端到端的可运行例子

需求:并发抓取 12 个接口,最多同时 4 个,任一个失败不影响其余,全部完成后统计成功与失败,整体超时 2 秒。

// 运行环境:Node.js 18+(用到全局 fetch),`node demo.mjs`
// 把 URL 换成自己项目的接口即可直接复用

// ——— 复用上一节的 pLimit ———
function pLimit(concurrency) {
  const queue = [];
  let activeCount = 0;
  const next = () => {
    activeCount--;
    if (queue.length) queue.shift()();
  };
  return (fn) => new Promise((resolve, reject) => {
    queue.push(async () => {
      activeCount++;
      try { resolve(await fn()); } catch (e) { reject(e); } finally { next(); }
    });
    if (activeCount < concurrency) queue.shift()();
  });
}

const limit = pLimit(4);

/** 带超时的单个请求:成功返回数据,失败抛出 Error —— 由调用方决定如何处理 */
async function fetchWithTimeout(url, ms) {
  const controller = new AbortController();
  const timer = setTimeout(() => controller.abort(), ms);
  try {
    const res = await fetch(url, { signal: controller.signal });
    if (!res.ok) throw new Error(`${url} 返回 HTTP ${res.status}`);
    return await res.json();
  } finally {
    clearTimeout(timer);   // 避免请求已结束后仍触发 abort
  }
}

async function main() {
  const urls = Array.from({ length: 12 }, (_, i) =>
    `https://jsonplaceholder.typicode.com/todos/${i + 1}`);

  const settled = await Promise.allSettled(
    urls.map((url) => limit(() => fetchWithTimeout(url, 2000))),
  );

  // 用 reduce 统计,比手动维护计数器更不容易写错
  const { ok, failed } = settled.reduce(
    (acc, r) => {
      if (r.status === 'fulfilled') acc.ok.push(r.value.id);
      else acc.failed.push(r.reason.message);
      return acc;
    },
    { ok: [], failed: [] },
  );

  console.log(`成功 ${ok.length} 个:`, ok);
  if (failed.length) console.warn(`失败 ${failed.length} 个:`, failed);
}

main().catch((err) => {
  // 兜底:任何意外都不让它变成 unhandledRejection
  console.error('未预期的错误:', err);
  process.exitCode = 1;
});

这段代码体现的四个模式值得记住:

  1. pLimit 控制并发:不炸接口、不触发浏览器连接数限制。
  2. AbortController 做真实超时:不只是"不再等待",而是真正中断请求,释放连接。
  3. allSettled 保证部分成功可用:批量任务用 allSettled 通常比 all 更合适。
  4. 顶层 catch 兜底:绝不让 Promise 拒绝逃逸成进程崩溃。

五、注意事项与常见坑

十个高频错误

1. await 忘了写:fetchUser() 返回 Promise,console.log(fetchUser()) 打印 Promise { <pending> }。

2. Array.prototype.forEach + async:forEach 会忽略回调返回的 Promise,循环「立刻结束」。

3. try/catch 包不住没 await 的 Promise:try { doAsync(); } catch {} 永远捕获不到。

4. 误以为 Promise.all 会取消其他任务:它只是「不再关心」,请求仍在后台跑完。

5. 误以为 Promise.race 只认成功:谁先落定谁赢,包括失败者,所以超时用它要小心。

6. res.json() 忘了 await:拿到的是 Promise 而非数据。

7. setTimeout(fn, 0) 当作「立即执行」:实际在微任务之后,且受 4ms 嵌套钳制。

8. async 函数作为事件监听器:addEventListener 不处理返回的 Promise,拒绝会变成未处理拒绝。

9. 在 Promise 构造器里做重活:executor 是同步执行的,写在这里的同步计算依然阻塞主线程。

10. 依赖 setTimeout 的精确延时:定时器只保证「不早于」,不保证「准时」。

调试技巧

- 输出顺序类问题,用 console.log + 编号手工推演一遍微任务/宏任务队列,比盯着代码看快得多。

- 断点打在 then 回调里,DevTools 的 Async 调用栈可以回溯到发起异步的位置。

- Node.js 里加 --trace-warnings 能看到「哪个 Promise 被拒绝却没处理」的详细信息。


六、练习题

题 1(事件循环输出顺序,必做)

下面代码在浏览器控制台中的输出顺序是什么?先自己写下答案再运行验证。

console.log(1);

setTimeout(() => console.log(2), 0);

Promise.resolve().then(() => console.log(3));

(async () => {
  console.log(4);
  await null;
  console.log(5);

  await Promise.resolve();
  setTimeout(() => console.log(6), 0);
  console.log(7);
})();

setTimeout(() => console.log(8), 0);

Promise.resolve().then(() => console.log(9)).then(() => console.log(10));

for (let i = 11; i <= 13; i++) console.log(i);

<details>

<summary>答案与逐步推演(点开)</summary>

输出顺序:1 4 11 12 13 3 5 9 7 10 2 8 6

(本题已用 Node.js 实测确认,输出为 1 4 11 12 13 3 5 9 7 10 2 8 6;浏览器中顺序一致。)

推演:

  1. 同步阶段按书写顺序执行:
  • 1
  • setTimeout(() => 2) → 宏任务队列 [2]
  • .then(() => 3) → 微任务队列 [3]
  • async IIFE 是「立即调用」,本轮同步执行到第一个 await 才让出 → 打印 4,在 await null 处暂停
  • setTimeout(() => 8) → 宏任务队列 [2, 8]
  • .then(() => 9).then(() => 10) → 微任务队列 [3, 9]
  • for 循环 → 11 12 13
  1. 清空微任务队列(初始为 [3, 9, async续体①]),按 FIFO 顺序:
  • 3 的回调 → 打印 3
  • 9 的回调 → 打印 9,并把 10 的回调注册到队尾
  • async 续体① → 打印 5;接着遇到 await Promise.resolve(),让出并把续体②注册到队尾
  • 此时队列为 [10的回调, async续体②]
  1. 继续清空微任务队列:
  • 10 的回调 → 打印 10
  • async 续体② → 先执行 setTimeout(() => 6, 0),把 6 追加到宏任务队尾,再打印 7
  1. 微任务清空完毕。宏任务队列此刻是 [2, 8, 6],依次执行 → 2、8、6。

两个易错点:

  • 以为 async 函数体是「异步开始」的,从而把 4 排到 11 12 13 之后。

实际上 async 函数调用时函数体同步执行,只在遇到 await 时才让出。

  • 以为 setTimeout(fn, 0) 注册得早就一定先执行。【6】是在第 3 步(微任务阶段)才注册的,

所以它排在【2】【8】之后——定时器的顺序由入队时刻决定,而不是回调里写的延迟值。

</details>

题 2(Promise 状态机)

await 一个已经 rejected 的 Promise,并用 try/catch 捕获;如果同一个 rejected Promise 被 await 两次,

第二次还会进入 catch 吗?为什么?

<details>

<summary>提示</summary>

会的。Promise 的状态与原因一旦落定就永久冻结,任何时刻、任何数量的 then/await 都能读到同一个拒绝原因。

这也是「Promise 可以多播(multicast)」的含义——与回调只能被调用一次不同。

</details>

题 3(并发改写)

下面的函数需要抓 200 个用户,但接口限流为「每秒最多 10 个请求」。请改写它,

要求总耗时可接受且不触发限流。

async function loadAll(ids) {
  const out = [];
  for (const id of ids) out.push(await fetchUser(id));   // 串行,极慢
  return out;
}

<details>

<summary>参考答案</summary>

用 pLimit(10) 限制并发,并叠加「每批之间等待 1 秒」或「令牌桶」策略:

// 运行环境:Node.js 18+(pLimit 沿用 3.5 节的定义)
async function loadAllThrottled(ids) {
  const limit = pLimit(10);
  const chunks = [];
  for (let i = 0; i < ids.length; i += 10) chunks.push(ids.slice(i, i + 10));

  const out = [];
  for (const chunk of chunks) {
    // 每批 10 个并发,批间等 1 秒 —— 满足「每秒最多 10 个」
    out.push(...(await Promise.all(chunk.map((id) => limit(() => fetchUser(id))))));
    await new Promise((r) => setTimeout(r, 1000));
  }
  return out;
}

注意 ...await 的括号

out.push(...await Promise.all(...)) 在多数运行环境下能解析,

但 ...await 连写的解析涉及 await 与展开运算符的优先级,加一层括号写成 ...(await ...) 更稳、可读性也更好。

注意点:pLimit(10) 保证同时在跑的不超过 10 个,但只要任务足够快,一秒内仍可能跑完好几批——

所以真实限流要么按时间窗口计数(令牌桶),要么按批 + 批间休眠。生产环境更推荐使用成熟的限流库。

</details>

题 4(手写题)

不使用 Promise.all,实现一个 myAll(promises),行为与 Promise.all 一致(含「空数组立刻 fulfilled」与「顺序与输入一致」)。

<details>

<summary>参考答案</summary>

// 运行环境:Node.js 18+
function myAll(iterable) {
  const items = [...iterable];
  return new Promise((resolve, reject) => {
    const results = new Array(items.length);
    let remaining = items.length;
    if (remaining === 0) return resolve(results);  // 空数组:立刻成功

    items.forEach((item, i) => {
      // 用 Promise.resolve 包一层,兼容非 Promise 的普通值
      Promise.resolve(item).then(
        (v) => {
          results[i] = v;                          // 按索引写入 → 顺序与输入一致
          if (--remaining === 0) resolve(results);
        },
        reject,                                    // 任意一个失败:立刻整体失败
      );
    });
  });
}

console.log(await myAll([1, Promise.resolve(2), 3])); // [ 1, 2, 3 ]
console.log(await myAll([]));                          // []

</details>

题 5(思考题)

setTimeout(fn, 0) 与 queueMicrotask(fn) 都能实现「当前代码之后执行」。请说明各自适用的场景,

并解释为什么把大循环切片时应该用 setTimeout 而不是 queueMicrotask。

<details>

<summary>参考思路</summary>

queueMicrotask 在当前宏任务结束后、渲染之前执行,且会把微任务队列跑干净——

如果用它在循环里递归切片,等于在同一个宏任务里连续跑完全部切片,渲染永远等不到机会,页面照样卡死。

setTimeout(fn, 0) 每次都会产生一个新的宏任务,宏任务之间浏览器才有机会渲染与处理用户事件,

所以「让出主线程」必须用宏任务。(代价是最小 4ms 的嵌套延迟。)

</details>


七、常见问题(FAQ)

Q1:Promise 是「多线程」吗?它到底在哪里执行?

A:不是。Promise 只是状态机 + 回调调度器,它的回调永远在主线程上执行。

真正「并行」的部分发生在宿主环境(网络线程、文件 I/O 线程、定时器线程),

主线程只负责在合适的时机把回调取回来跑。所以 new Promise 里写 while(true) 一样会卡死页面。

Q2:async 函数和 Promise 有性能差别吗?

A:几乎没有。async/await 是建立在 Promise 之上的语法糖(V8 内部还会做优化)。

差别主要在可读性与错误处理:await 能用 try/catch,then 链需要 .catch。

性能上真正要关心的是「有没有把能并行的任务写成了串行」,而不是选哪种语法。

Q3:为什么 setTimeout(fn, 0) 有时延迟十几毫秒?

A:三个因素叠加:①它是宏任务,要等当前宏任务与所有微任务跑完;

②嵌套超过 5 层后最小延迟被钳制为 4ms;

③渲染、其他宏任务、浏览器自身的调度都会插在前面。

定时器只保证「不早于」,不保证「准时」,任何依赖精度的逻辑(如动画)都应该用 requestAnimationFrame。

Q4:await 会让出主线程,是不是等于「不阻塞」?

A:不等于。await 只是让当前函数暂停,主线程照样在跑别的任务;

而 await 之后恢复执行的那段代码依然是同步阻塞的。

如果你 await 一个耗时 5 秒的纯计算(await heavyCompute()),主线程照样卡 5 秒——

因为计算本身在调用时就同步开始了。真正的解法是把计算切分,或搬到 Web Worker / Worker Threads。


相关笔记

  • JavaScript-02-函数与作用域:闭包与 this 是理解回调、Promise 链中上下文的前提
  • JavaScript-05-DOM与事件:事件监听器本质上也是异步回调,事件循环是事件模型的地基
  • JavaScript-06-模块化与工程化:ESM 的顶层 await、打包工具对异步代码的处理
  • 后端-02-Nodejs与Express:Node.js 事件循环的六个阶段与中间件里的异步写法
  • CSharp-05-异步编程:对比 Task/async/await 与 JS 的异同,理解「语言级协程」与「事件循环」的区别

参考来源

  • MDN 中文:《使用 Promise》 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Guide/Using_promises
  • MDN 中文:Promise https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise
  • MDN 中文:Promise.allSettled()(含四种组合方法的行为定义) https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/allSettled
  • MDN 中文:Promise.any()(AggregateError 行为) https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/any
  • MDN 中文:async function 声明 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/async_function
  • MDN 中文:for await...of https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Statements/for-await...of
  • MDN 中文:AbortController https://developer.mozilla.org/zh-CN/docs/Web/API/AbortController
  • MDN 中文:setTimeout()(嵌套 4ms 最小延迟的规范说明) https://developer.mozilla.org/zh-CN/docs/Web/API/Window/setTimeout
  • 现代 JavaScript 教程(中文):《事件循环:微任务和宏任务》 https://zh.javascript.info/event-loop
  • 现代 JavaScript 教程(中文):《Promise API》 https://zh.javascript.info/promise-api
  • ECMAScript 规范:Control Abstraction Objects(Promise 与 Await 的抽象操作) https://tc39.es/ecma262/multipage/control-abstraction-objects.html
  • Node.js 官方文档:process.nextTick 与 queueMicrotask 的取舍、'unhandledRejection' 事件 https://nodejs.org/docs/latest/api/process.html
  • Node.js 官方文档:Timers(setImmediate 与事件循环阶段) https://nodejs.org/docs/latest/api/timers.html
  • 说明:AbortSignal.timeout / AbortSignal.any 等较新 API 的浏览器支持情况易变,请以 MDN 与目标运行环境的最新文档为准。