浅谈 JS 异步

刚从 C 或 Java 转来写 JavaScript / Node.js 的时候,很多人最不适应的就是它的异步机制。在传统的同步思维里,代码严格一行行往下跑,前一行执行完了才走下一行;但在 JavaScript 中,这种直觉常常会被“打脸”。

本文从最基础的困惑切入,系统梳理 JavaScript 异步方案的演进历程:回调函数 $\to$ 事件监听 $\to$ Promise $\to$ async/await,并通俗拆解其背后的执行机制。


一、初学者的困惑:为什么它不按顺序出牌?

来看一段最经典的代码:

1
2
3
4
5
6
7
console.log('begin');

setTimeout(() => {
console.log('1s');
}, 1000);

console.log('end');

实际运行输出:

1
2
3
begin
end
1s

很多刚接触前端的同学第一反应是:“我明明在中间写了输出 1s,为什么 end 会先跑出来?”

如果必须让代码严格按照 begin -> 1s -> end 的顺序执行,我们不得不把 end 塞进 setTimeout 的回调函数里:

1
2
3
4
5
6
console.log('begin');

setTimeout(() => {
console.log('1s');
console.log('end');
}, 1000);

这是因为 setTimeout 接收的第一个参数是一个异步回调函数。


二、回调函数就一定是异步的吗?

这里必须澄清一个常见的误区:回调函数(Callback)本身并不等于异步!

在 JavaScript 中,回调函数分为两种:

1. 同步回调

回调函数在当前主线程的执行栈中立即、同步执行完毕,不会排队等待。最典型的就是数组的原生高阶函数:

1
2
3
4
5
6
7
8
9
10
console.log('开始遍历');

[1, 2, 3].forEach((item) => {
console.log(item); // 这里的箭头函数就是同步回调
});

console.log('遍历结束');

// 输出严格有序:
// 开始遍历 -> 1 -> 2 -> 3 -> 遍历结束

2. 异步回调

回调函数不会立刻执行,而是被挂起或注册到宿主环境中,等异步事件(网络请求、定时器到期、磁盘 I/O)触发后,才将回调推进任务队列中等待主线程调度:

1
2
3
4
5
6
7
8
9
10
11
12
const fs = require('fs');

console.log('开始读文件');

fs.readFile('./test.txt', 'utf8', (err, data) => {
console.log('文件内容读取完毕'); // 异步 I/O 回调
});

console.log('主线程继续走');

// 输出顺序:
// 开始读文件 -> 主线程继续走 -> 文件内容读取完毕

三、异步演进史:从痛苦到优雅

异步虽然让 Node.js 具备了高并发、不阻塞主线程的超强性能,但如何组织异步代码,经历了漫长而痛苦的探索。

阶段 1:回调函数与“回调地狱(Callback Hell)”

最早我们只能把后续逻辑一层层嵌套在回调函数里。当多个异步操作存在依赖顺序时(比如:先查用户 -> 再查订单 -> 再查物流详情),代码就会不可避免地陷入恶名昭彰的金字塔型回调地狱:

1
2
3
4
5
6
7
getUser(userId, (user) => {
getOrder(user.id, (order) => {
getShipping(order.id, (shipping) => {
// 缩进越来越深,错误捕获极度混乱
});
});
});

阶段 2:事件发布/订阅模式(EventEmitter)

在 Node.js 中,还可以使用 events 模块通过发布订阅来解耦异步流:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const EventEmitter = require('events');
const eventBus = new EventEmitter();

console.log('begin');

eventBus.on('done', (data) => {
console.log(data);
console.log('end');
});

setTimeout(() => {
console.log('1s');
eventBus.emit('done', 'timeout');
}, 1000);

事件监听适合用于多对多的事件驱动系统(如网络 Socket 数据帧到来),但对于线性、强前后依赖的常规业务逻辑,频繁定义各种 event name 反而让调用关系分散难寻。

阶段 3:Promise 扁平化链式调用

ES6 正式引入的 Promise 是解决回调地狱的一大里程碑。它将深层嵌套的树状结构,拍平成了线性流式的链式调用:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
console.log('begin');

function sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}

sleep(1000)
.then(() => {
console.log('1s');
return sleep(1000);
})
.then(() => {
console.log('2s');
console.log('end');
})
.catch((err) => {
console.error('统一异常捕获:', err);
});

Promise 的好处是视觉上变清晰了,并且有了统一的 .catch() 异常捕获机制;但本质上,.then() 内部依然需要传递回调函数。

阶段 4:async / await 终极语法糖

ES2017 推出的 async / await 彻底终结了异步代码难写的历史。

所谓的“语法糖”,就是外表包裹了甜美糖衣的底层机制。async/await 的底层其实就是 Promise + Generator 协同调度器。它允许开发者用写同步代码的心智模型,来写异步非阻塞逻辑:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function sleep(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}

async function run() {
console.log('begin');

// await 会暂停当前 async 函数的继续执行,等待 Promise resolve
await sleep(1000);
console.log('1s');

await sleep(1000);
console.log('2s');

console.log('end');
}

run();

现在代码逻辑一目了然,再也没有层层缩进与回调嵌套!


四、写好 async/await 的两大实战要点

1. 优雅的异常捕获(try…catch)

在 async 函数内部,Promise 的 reject 会直接以异常形式抛出,因此直接使用熟悉的 try...catch 即可全流程兜底:

1
2
3
4
5
6
7
8
async function fetchData() {
try {
const res = await api.getUser();
console.log('成功:', res);
} catch (err) {
console.error('请求失败:', err.message);
}
}

2. 避免无意识的串行变慢(Promise.all 并发提速)

很多人初学 async/await 时,喜欢一路 await 到底:

1
2
3
4
5
6
// ❌ 低效:两个没有依赖关系的请求被强行串行,耗时 = 1s + 1s = 2s
const user = await fetchUser();
const news = await fetchNews();

// ✅ 高效:利用 Promise.all 并发请求,耗时 = max(1s, 1s) = 1s
const [user, news] = await Promise.all([fetchUser(), fetchNews()]);

五、底层原理:为什么异步总是在最后执行?(简说 Event Loop)

很多同学会好奇:如果 setTimeout(..., 0) 延迟设为 0 毫秒,它会比后续的 console.log('end') 先执行吗?

1
2
3
4
5
setTimeout(() => console.log('定时器执行'), 0);
console.log('主线程代码');

// 结果依然是:
// 主线程代码 -> 定时器执行

答案是依然在最后执行。这是由 JavaScript 单线程的 事件循环(Event Loop) 决定的:

1
2
3
4
5
6
7
8
主线程执行栈 (Call Stack)                 任务队列 (Task Queue)
┌──────────────────────┐ ┌──────────────────────┐
│ 执行同步代码 │ │ 异步回调排队等待中: │
│ console.log('主线程') │ │ - setTimeout callback│
└──────────────────────┘ └──────────────────────┘
│ ▲
▼ (执行栈全部清空后) │
└─────────> 事件循环 (Event Loop) ────────┘
  1. 单线程执行栈(Call Stack):浏览器或 Node.js 会优先一口气把当前所有的同步代码全部推入执行栈执行完;
  2. 异步进队列:当遇到 setTimeout 或 I/O 时,宿主环境在后台计时,到期后将回调放进**任务队列(Task Queue)**排队;
  3. 事件循环调度:只有当主线程的执行栈完全清空为空时,事件循环才会去任务队列里把排队的回调捞出来放进执行栈执行。

总结

JavaScript 的异步机制并非刻意刁难开发者,而是单线程语言为了避免“一个网络请求卡死整个网页或服务器”而做出的天才架构设计。

从最初的 Callback 地狱,到 Promise 链式规范,再到如今像写同步代码一样自然的 async / await,理清这套演进脉络与任务调度逻辑,写起复杂业务逻辑便能得心应手。


参考资料与延伸阅读

1. 语言与标准规范

2. 底层运行机制与事件循环


浅谈 JS 异步
https://bubao.github.io/posts/8e5102f6.html
作者
一念
发布于
2019年12月17日
许可协议