你的 Node 服务只有一个线程,却扛住了十万并发:事件循环的真相,和它翻车的三种姿势

2026-11-18 19 0

我第一次看到公司的 Node 网关同时挂着十万长连接时,内心是懵的。一个单线程的东西,凭什么?后来我自己上手写了几轮,越写越觉得这事被科普得稀烂:Node 的并发不是真并发,是"线程外并发"。它不是 Go 那种成千上万的 goroutine,而是一个线程在事件循环里来回跑,I/O 的时候把活儿丢给内核和 libuv,等回调回来再接着跑。

用得好,它比多线程服务省心得多;用不好,它能让你在流量平稳的时候突然全体卡死。所以这篇把这套机制拆开看,顺便聊聊那三个最容易把人送走的坑。


一、先泼一盆冷水:Node 没有并发,只有"假装并发"

Java 里你起 200 个线程,机器就真的开了 200 条执行流。Node 不是。Node 的 JavaScript 线程只有一条,剩下能并行干活的全是 libuv 拉起来的工作线程池,默认 4 个。

这意味着两件事:任何纯 CPU 计算在 Node 里都是单线程排队,没有例外;任何看起来像异步但其实是同步的 API,都会在主线程上当场执行。

很多人以为 Node 因为跑在 V8 上所以快。真相是:V8 确实快,但快也架不住你在一个线程里塞十万个 JSON.parse。人话就是,Node 的并发上限不是 CPU 决定的,是你的代码有没有阻塞事件循环决定的。


二、事件循环的六站:你的回调到底跑在哪一站

先把这六个阶段记牢,后面所有坑都从这里长出来:

  1. timers:setTimeout、setInterval 到点执行;
  2. pending callbacks:被推迟到下一轮的 I/O 回调;
  3. idle / prepare:内部使用,不用管;
  4. poll:真正取 I/O 事件的地方,队列空了它会在这里睡着;
  5. check:setImmediate 的主场;
  6. close callbacks:比如 server.close() 之后的收尾。

关键结论只有一条:这六站是循环转的,每转完一轮,才清空微任务队列(Promise 回调、process.nextTick)。

setTimeout(() => console.log('timeout'), 0);
Promise.resolve().then(() => console.log('promise'));
process.nextTick(() => console.log('nextTick'));
setImmediate(() => console.log('immediate'));

输出是:nextTick → promise → timeout → immediate。nextTick 插队插在微任务最前面,比 Promise 还早。顺便吐槽:把 setTimeout(fn, 0) 当"下一帧"用的人很多,但语义上更接近"尽快、在 I/O 之后"的是 setImmediate。名字骗人,行为更骗人。


三、坑一:libuv 线程池默认只有 4 个

调用 fs.readFile、fs.writeFile、部分 crypto 操作、DNS 查询时,Node 并没在主线程干活,而是丢给 libuv 的线程池。默认池子大小:4。

于是有了这个经典现场:一次要读 10 个 200MB 文件,4 个线程忙得脚不沾地,第 5 个请求进来就在 poll 阶段干等。监控上 CPU 只有 30%,QPS 却从 800 掉到 80,所有人开始怀疑服务器是不是不够大。

解法朴实无华:UV_THREADPOOL_SIZE=32。但这只是把墙推远了一步。大文件读取本来就不该走线程池,正确姿势是流式:

import { createReadStream, createWriteStream } from 'node:fs';
import { pipeline } from 'node:stream/promises';

await pipeline(
  createReadStream('/data/big.bin'),
  createWriteStream('/data/out.bin')
);

流式处理不占线程池、不占内存、不阻塞事件循环,这才是 Node 处理大文件的正道。


四、坑二:事件循环被"同步"两个字拖死

最常见的翻车姿势,而且现场极难查:

// ❌ 请求处理函数里,它会直接卡住整个进程
const raw = fs.readFileSync('./config.json', 'utf8');
const hash = crypto.createHash('md5').update(bigBuffer).digest('hex');

这类代码小流量下毫无问题,日志也干干净净,直到某天一个 100MB payload 进来,整台机器上的 HTTP 请求集体超时,连接数打满,重启才活。

Node 有个环境变量叫 UV_THREADPOOL_SIZE,还有一个更值得记住的:凡是带 Sync 后缀的 API,都会在主线程上同步执行。这个命名法是 Node 做得最漂亮的设计之一——它把危险直接写在了函数名里。

至于 CPU 密集型任务(加密、压缩、大对象序列化、复杂正则回溯),老实说:上 worker_threads,别幻想。

import { Worker } from 'node:worker_threads';

function runHeavy(task) {
  return new Promise((resolve, reject) => {
    const w = new Worker('./worker.js', { workerData: task });
    w.once('message', resolve);
    w.once('error', reject);
  });
}

主线程负责"接待",worker 负责"干活",这才是单线程语言该有的分工。顺便说一句,滥用 worker_threads 也是一种病:起 200 个、每个 50MB 内存,那不叫并行,那叫自杀。


五、坑三:await 在循环里,你亲手写了个并发为 1 的并行

// ❌ 完全串行:100 个请求 = 100 倍延迟
for (const id of ids) {
  results.push(await fetchUser(id));
}

// ✅ 并行
const results = await Promise.all(ids.map(id => fetchUser(id)));

但 Promise.all 也有坑:一次性打 5000 个请求出去,对面不把你当 DDoS 拉黑才怪。生产环境该配一个并发上限:

async function mapLimit(items, limit, fn) {
  const out = new Array(items.length);
  let idx = 0;
  const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
    while (idx < items.length) {
      const i = idx++;
      out[i] = await fn(items[i]);
    }
  });
  await Promise.all(workers);
  return out;
}

const users = await mapLimit(ids, 20, fetchUser);

顺手再提一句超时:Node 18+ 内置了 fetch,但它没有默认超时。一个挂掉的下游能把连接池吃干净,然后你会看到内存涨、FD 涨、事件循环延迟涨,三条曲线一起跳。

const res = await fetch(url, { signal: AbortSignal.timeout(3000) });

三行代码,把事故掐死在摇篮里。


六、给你的 Node 服务装一副"心电图"

最便宜的监控是内置的 perf_hooks,能直接量出事件循环延迟,也就是"本该立刻执行的任务实际被拖了多少毫秒"。超过 50ms 就该紧张,超过 200ms 说明已经在拖垮整个进程了。

import { monitorEventLoopDelay } from 'node:perf_hooks';

const h = monitorEventLoopDelay({ resolution: 10 });
h.enable();

setInterval(() => {
  console.log({
    mean: (h.mean / 1e6).toFixed(2),
    max: (h.max / 1e6).toFixed(2),
    p99: (h.percentile(99) / 1e6).toFixed(2)
  });
  h.reset();
}, 5000).unref();

把这几个数接进监控面板,比看 CPU 有用一百倍。CPU 绿着而延迟飙红,是 Node 服务最典型的病灶特征。

再往上,工具也是现成的:clinic doctor 给你火焰图,0x 能对比两次采样,async_hooks 可以追踪异步资源的生命周期。


七、收工清单

  • 代码里出现 Sync 后缀,先问一句"这玩意儿会不会挡住别人";
  • 大文件一律走 stream,别碰 readFile / readFileSync;
  • CPU 密集型丢进 worker_threads,线程数要克制;
  • await 不要写在 for 循环里,并行记得配上限和超时;
  • 把事件循环延迟监控接上,p99 别让它静悄悄地爬;
  • CPU 低但接口慢,先怀疑事件循环被阻塞,而不是机器不够。

说到底,Node 的哲学是"单线程 + 异步 I/O",它从来不承诺 CPU 密集型场景下的表现,也不需要承诺。它擅长的从来只有一件事:用最少的线程扛住最多的连接。你把活儿分清楚,它就能替你扛住;你把 CPU 活儿丢给它,它就会用行动教育你什么叫"单线程"。

再吐槽一句:我见过把 Node 当 Spring 用、给它配齐"微服务 + 注册中心 + 熔断 + 消息队列"全套家桶的项目,最后发现真正干活的还是那一个线程。架构师加的每一层,都只是给那次事件循环阻塞加了更响的报警器。

相关文章

42 KB 的请求,打爆 126 MB 的内存:gzip 解压炸弹,你的接口正裸奔
缓存没坏,你的服务却挂了:穿透、击穿、雪崩,以及那份永远对不上的数据
你的写入明明很快,直到磁盘开始抖:LSM-Tree 的三把刀,和一次 RocksDB 磁盘风暴复盘
一个连接扛住十倍并发,然后被自己的 64KB 掐死了:HTTP/2 流控窗口的真相
你的搜索为什么慢得像在刨坟:Elasticsearch 倒排索引的一次翻车现场
你加了一个字段,生产环境炸了:论 API 兼容性的真正战场

发布评论