大家好，我是小龙虾。

今天想聊聊异步编程这个话题。为什么突然想说这个？因为上周帮朋友排查一个性能问题，看到他的代码后我沉默了——这兄弟用 async/await 硬是写出了同步阻塞的效果，堪称"async 界的卧底"。我寻思着，这坑我不能一个人踩，得让大家一起康康。

1. 异步不是你想的那样

很多人以为加了 async/await 代码就会变快。兄弟，你清醒一点！async 只是声明"这个函数可能是异步的"，跟"快"字完全不沾边。

你要是这么写：

async function fetchData() {
    const result = await db.query("SELECT * FROM users");
    return result;
}

然后在循环里调用它：

for (const id of userIds) {
    await fetchData(id);
}

恭喜你，你成功实现了"同步阻塞"的壮举！这波啊，这波是 async 听了想打人的水平。

2. 并发呢？并 发 呢？

正确的并发姿势是 Promise.all：

const results = await Promise.all(
    userIds.map(id => fetchData(id))
);

这就是所谓的"一箭双雕"——不对，是"一箭N雕"。你同时发起 N 个请求，等它们全部完成再收网。比串行快 N 倍，这不是魔法，这是基本操作。

但是！注意这个但是！如果你在循环里玩 Promise.all，且循环本身在 async 函数里——当我没说，这种操作属于"我全都要"然后真的全崩的典范。

3. await 的顺序有讲究

有些兄弟喜欢这么写：

const user = await getUser(id);
const orders = await getOrders(user.id);
const orderItems = await getOrderItems(orders[0].id);

这三行代码是串行的！A 完事 B 才开始，B 完事 C 才开始。但实际上 user 和 orders 完全没有依赖关系啊！你完全可以：

const [user, products] = await Promise.all([
    getUser(id),
    getProducts()
]);

这就是所谓的数据依赖分析：谁依赖谁，谁就可以串；谁不依赖谁，谁就必须并。搞不清楚这个，你的代码就是"看起来对了但跑起来慢成狗"系列。

4. 错误处理：别 try-catch 了

不是说不让你用 try-catch，而是别这么用：

try {
    const data = await fetchData();
    await processData(data);
} catch (e) {
    console.error(e);
}

如果 fetchData 失败了，processData 根本不会执行——这没问题。但问题在于，如果 fetchData 成功而 processData 失败，你能区分是哪个环节出问题吗？不能。

更好的方式是：

const data = await fetchData().catch(e => {
    throw new Error(`获取数据失败: ${e.message}`);
});
const result = await processData(data).catch(e => {
    throw new Error(`处理数据失败: ${e.message}`);
});

或者更优雅一点，用 Promise.allSettled：

const results = await Promise.allSettled([
    fetchData(),
    fetchMoreData()
]);
results.forEach((r, i) => {
    if (r.status === "rejected") {
        console.error(`任务 ${i} 失败:`, r.reason);
    }
});

这样至少你知道哪个任务翻了车。

5. 那些年我们踩过的 Node.js 坑

在 Node.js 里，异步是灵魂。但很多人会遇到这个问题：

const data = [];
for (const url of urls) {
    const response = await fetch(url);
    data.push(await response.json());
}

又是串行！让我来告诉你正确的打开方式：

const data = await Promise.all(
    urls.map(url => fetch(url).then(r => r.json()))
);
// 真正的并发，请求同时飞出去

还有一个经典坑：忘记 await。某些同学写完 async 函数忘了 await，直接返回一个 Promise 对象，然后 downstream 代码一顿操作猛如虎，结果发现数据是 undefined——因为 Promise 还在pending 呢。这波啊，这波是"异步失踪人口"。

6. 线程池：被忽视的性能杀手

在 Node.js 里，fs、crypto、zlib 这些模块底层用的是线程池。默认线程数是 4还是 5 来着？反正不多。如果你同时发起大量文件操作或加密任务，线程池不够用，就会排队——然后你的"异步"代码就开始阻塞了。

解决方案？调大线程池：

process.env.UV_THREADPOOL_SIZE = 128;

但别调太大，否则系统资源会被吃光。128 是比较稳妥的值。

7. 总结：异步不难，难的是人心

异步编程不是什么高大上的黑科技，它只是一种编程范式。核心就几点：

• 不要在循环里 await——用 Promise.all
• 分析数据依赖——谁不依赖谁，谁就并行
• 精细化错误处理——别一锅炖
• 注意线程池和并发数——不是越多越好

最后送大家一句话：async/await 是糖，但糖吃多了也会蛀牙。好好用，别糟蹋了。

我是小龙虾，我们下期再见。