罗罗编程学习记录
本页内容 展开查看

04.2.1.1 架构分层与事件循环阶段

所属:全栈开发面试题库 / 04 后端语言与运行时 / 04.2 Node.js / 04.2.1 运行时与事件循环

04.2.1.1-001 Node.js 运行时由哪几层组成?

一句话结论

Node.js 由 V8 引擎、libuv 异步 IO 库、内置 C/C++ 绑定层和 JS 内置模块四层组成,JS 代码通过绑定层调用底层能力。

概念解释

Node 是让 JavaScript 脱离浏览器运行的服务端运行时。V8 负责解析、编译、执行 JS 并管理堆内存;libuv 提供事件循环、线程池和 IO 多路复用;内置模块(fs、net、http 等)是 JS 包装层。

原理流程

  1. 入口 JS 文件进入 V8 编译执行。
  2. 需要 IO 或系统能力时,JS 模块经绑定层调用 C++ 实现。
  3. C++ 层把异步请求交给 libuv,就绪后回调 JS。

代码或图示

JS 业务代码 / 内置 JS 模块(fs、http、stream ...)
  └── C++ 绑定层
        ├── V8:代码执行、堆、GC
        └── libuv:事件循环、线程池、多路复用

常见误区

  • 把 Node 当成“纯 JS 环境”:核心 IO 能力来自 C/C++ 原生层。
  • 认为 V8 负责网络调度:V8 只管 JS 执行,IO 等待与回调调度是 libuv 的职责。

追问

  • libuv 是 Node 独有的吗?答:不是,它是独立的跨平台 C 库,也被其他运行时使用。
  • 内置模块分哪两类?答:纯 JS 模块(events、util)和依赖 C++ 绑定的模块(fs、net、crypto)。

04.2.1.1-002 Node 是单线程吗?

一句话结论

执行 JavaScript 的是单线程(主线程),但底层有 libuv 线程池和网络 IO 多路复用线程,“单线程”只指 JS 执行线程。

概念解释

JS 代码、回调执行、事件循环都在主线程串行跑;文件 IO、DNS、加密等阻塞式系统调用放到 libuv 线程池,网络连接由操作系统多路复用监听,不占线程等待。

原理流程

  1. 主线程把异步操作下发到底层。
  2. 线程池任务或网络事件就绪后进入事件循环队列。
  3. 主线程在对应阶段取出回调执行。

代码或图示

主线程(JS 执行) ──下发──> libuv 线程池 / 网络多路复用
        ↑ 就绪回调回到主线程执行

常见误区

  • “Node 单线程所以只能用一个 CPU 核”:可通过 cluster 多进程、worker_threads 多线程利用多核。
  • “线程池线程在跑 JS”:线程池只执行原生阻塞调用,回调仍回主线程。

追问

  • 高并发来自什么?答:非阻塞 IO + 事件循环挂起大量连接,不是多线程跑 JS。
  • CPU 密集任务为什么拖垮服务?答:占住主线程后其他回调无法被调度。

04.2.1.1-003 事件循环在进程生命周期中处于什么位置?

一句话结论

进程启动后先加载入口模块、执行同步顶层代码,然后进入事件循环;只要还有待处理句柄或定时器,循环就持续运转,全部清空后退出。

概念解释

事件循环是 libuv 的调度中枢:不断检查各阶段队列,取出到期/就绪回调交给主线程。顶层同步代码在进入循环之前执行。

原理流程

  1. 解析参数、加载内置模块。
  2. 执行入口文件顶层同步代码。
  3. 进入事件循环按阶段轮转处理回调。
  4. 无句柄、无定时器、无待处理请求时退出并触发 exit 事件。

代码或图示

启动 → 顶层同步代码 → 进入事件循环 → 轮转阶段 → 清空后退出

常见误区

  • 以为 setTimeout(fn, 0) 的回调在顶层代码之前排队:它要等进入 timers 阶段才执行。
  • 以为进程会一直挂着:没有保持存活的句柄时,循环空转一圈后退出。

追问

  • 什么算保持存活的句柄?答:网络连接、文件监听、定时器、worker 线程等。
  • 顶层 await(ESM)算在哪个阶段?答:阻塞模块完成,后续回调仍由事件循环调度。

04.2.1.1-004 事件循环六个阶段分别处理什么?

一句话结论

六阶段依次为 timers → pending callbacks → idle/prepare → poll → check → close callbacks,每阶段执行自己的回调队列,阶段之间清空微任务。

概念解释

阶段是 libuv 对不同就绪事件的归类:定时器到期、IO 错误回调、内部准备、网络 IO、setImmediate、连接关闭。

原理流程

  1. timers:到期的 setTimeout/setInterval 回调。
  2. pending callbacks:延迟到下一轮的系统错误等回调。
  3. idle/prepare:libuv 内部使用。
  4. poll:取回已就绪 IO 事件并执行回调。
  5. check:执行 setImmediate 回调。
  6. close callbacks:执行 socket 等 close 事件回调。

代码或图示

timers → pending callbacks → idle/prepare → poll → check → close callbacks

常见误区

  • 把六阶段理解成六个 JS 线程:它们是同一主线程上的调度顺序。
  • 认为所有 IO 回调都在 poll 阶段立即执行:部分错误回调推迟到 pending callbacks。

追问

  • 阶段间微任务清空顺序?答:先 nextTick 队列,再 Promise 微任务队列(见 04.2.1.2)。
  • 一轮跑完一定再跑 timers 吗?答:有待处理句柄或到期定时器就继续下一轮。

04.2.1.1-005 timers 阶段:定时器回调何时执行,为什么不准时?

一句话结论

定时器回调在 timers 阶段执行,到期后还要等主线程跑到该阶段才被调度,实际延迟通常大于设定值。

概念解释

定时器只记录到期时间点,不保证准时中断当前执行。主线程被长同步任务占用、前阶段队列积压、系统调度抖动都会造成偏差。

原理流程

  1. setTimeout(fn, delay) 登记到期时间。
  2. 进入 timers 阶段扫描已到期定时器。
  3. 按登记顺序执行到期回调,未到期留到下一轮。

代码或图示

登记到期时间 → 到达 timers 阶段 → 扫描到期 → 执行回调

常见误区

  • 把 setTimeout(fn, 0) 当“下一毫秒必执行”:0 延迟归一化,且受主线程占用影响。
  • 用定时器做高精度计时:高精度计时用 perf_hooks / process.hrtime。

追问

  • 为什么回调经常比 delay 晚?答:主线程当前任务未结束、队列积压、系统调度都会延后。
  • setInterval 回调会重叠吗?答:主线程忙时排队,下一次可能紧接着执行,不会并行。

04.2.1.1-006 pending callbacks 阶段处理哪些回调?

一句话结论

该阶段执行上一轮被推迟的部分系统级回调,例如某些 TCP 错误(如 ECONNREFUSED)和少数内部 IO 回调。

概念解释

不是所有 IO 事件都在 poll 阶段:部分错误事件被推迟到下一轮的 pending callbacks,避免在 poll 阶段重入。业务代码一般不直接感知这个阶段。

原理流程

  1. 上一轮 poll 阶段标记需延迟处理的错误事件。
  2. 下一轮进入 pending callbacks 阶段执行。
  3. 随后进入 idle/prepare。

代码或图示

poll 标记延迟事件 → 下一轮 pending callbacks 执行 → idle/prepare

常见误区

  • 以为所有错误回调都紧跟 IO 失败后执行:部分错误要等到 pending callbacks 阶段。
  • 业务代码能控制进入哪个阶段:不能,只能通过 API 间接选择阶段。

追问

  • 哪些 API 对应这个阶段?答:以系统级错误回调为主,业务回调主要落在 timers/poll/check。
  • 这个阶段对业务代码可见吗?答:业务一般不直接感知,主要是系统级错误回调;写业务回调时无需针对该阶段编排。

04.2.1.1-007 idle/prepare 阶段是做什么的?

一句话结论

idle/prepare 是 libuv 内部使用的阶段,调度内部任务和准备 poll 阶段参数,业务代码不直接注册回调。

概念解释

事件循环需要为内部维护预留位置。这两个阶段跑 libuv 自身簿记逻辑,公共 API 没有把回调注册到这里的入口。

原理流程

  1. 运行时内部簿记与状态准备。
  2. 计算 poll 阶段等待参数。
  3. 进入 poll 阶段。

代码或图示

内部任务调度 → poll 参数准备 → poll

常见误区

  • 以为存在 API 可把回调注册到 idle 阶段:标准公共 API 没有该入口。
  • 把 idle 阶段理解成“主线程空闲时的兜底任务”:它不是用户任务队列。

追问

  • 为什么文档要列出这个阶段?答:完整描述循环结构,理解阶段衔接关系。
  • prepare 阶段具体做什么?答:prepare 在 idle 之后、poll 之前做内部准备工作,同样不暴露给用户代码。

04.2.1.1-008 poll 阶段如何决定阻塞等待多久?

一句话结论

poll 先执行就绪 IO 回调;队列为空时,有到期定时器或待执行 setImmediate 就不阻塞,否则阻塞等待新 IO 事件。

概念解释

poll 是网络 IO 事件的主要处理阶段。它不是无限阻塞:有待执行任务时缩短等待,保证 timers/check 阶段能及时运行。

原理流程

  1. 取出 poll 队列就绪 IO 回调并执行。
  2. 检查是否有 setImmediate 排队、定时器是否即将到期。
  3. 有任务短等或不阻塞,否则阻塞到下一个事件或超时。

代码或图示

执行就绪 IO → 检查 check/timers 任务 → 决定阻塞时长 → 等待或继续

常见误区

  • 认为 poll 会一直阻塞直到新连接:有待处理回调或到期定时器时立即退出等待。
  • 阻塞期间 IO 回调被打断执行:阻塞期间由内核监听,就绪后下一轮取回调。

追问

  • poll 阶段阻塞会卡主线程吗?答:这里是让出等待 IO,不是占着线程算东西。
  • poll 的阻塞时长由什么决定?答:由到期定时器、待处理回调数和 libuv 计算出的超时值决定;没有事件时才进入等待。

04.2.1.1-009 check 阶段为什么对应 setImmediate?

一句话结论

setImmediate 回调在 check 阶段执行,设计意图是在当前 poll 完成、下一轮 timers 之前插入一次执行。

概念解释

check 紧跟 poll 之后,专门处理 setImmediate。它与 setTimeout 定位不同:setImmediate 表达“本轮 IO 完成后尽快执行”,不是“等固定时长”。

原理流程

  1. IO 回调在 poll 阶段执行完。
  2. 进入 check 阶段取出 setImmediate 回调。
  3. 执行后进入 close callbacks 或下一轮。

代码或图示

poll(IO 回调)→ check(setImmediate)→ close callbacks

常见误区

  • 以为 setImmediate 比 setTimeout 更快:先后取决于代码所处阶段(见 04.2.1.2)。
  • 把 setImmediate 当 nextTick 用:nextTick 当前操作后插队,setImmediate 等下一阶段。

追问

  • IO 回调里 setImmediate 为什么通常先于 setTimeout(fn, 0)?答:IO 回调后直接进 check,定时器可能还没到期。
  • check 阶段除 setImmediate 还跑什么?答:主要是 setImmediate 回调;它与 close callbacks 区分,后者处理句柄关闭事件。

04.2.1.1-010 close callbacks 阶段处理什么?

一句话结论

该阶段执行对象关闭时触发的 close 事件回调,例如 socket、handle 的 'close' 事件。

概念解释

句柄主动/被动关闭后,关闭事件回调放到 close callbacks 阶段,与普通数据回调区分。socket.on('close', ...) 注册的回调在这里运行。

原理流程

  1. 句柄关闭产生 close 事件。
  2. 事件进入 close callbacks 队列。
  3. 本轮循环末尾执行对应回调。

代码或图示

句柄关闭 → close 事件入队 → close callbacks 阶段执行

常见误区

  • 把 close 事件和 finish 事件混淆:finish 表示写完数据,close 表示底层句柄已关闭。
  • 以为 close 回调会打断当前阶段:排队到本阶段统一执行。

追问

  • close 与 end 区别?答:close 是句柄关闭事件,end 是可读流数据读完。
  • 哪些对象会触发 close?答:net.Socket、fs 流、server 等持有底层句柄的对象,关闭后触发 'close' 事件。

04.2.1.1-011 阶段之间微任务在什么时机清空?

一句话结论

每个阶段回调执行完、进入下一阶段前清空微任务队列:nextTick 队列优先,再 Promise 微任务队列;Node 11 后单个宏回调后也清空微任务。

概念解释

微任务是“本轮收尾”性质,优先级高于下一阶段宏任务。回调里追加的微任务会在当前队列清空前继续执行,可能延后后续宏任务。

原理流程

  1. 当前阶段取出一个宏回调执行。
  2. 收集期间产生的微任务。
  3. 清空 nextTick 队列,再清空 Promise 队列。
  4. 回到阶段队列取下一个回调。

代码或图示

宏回调执行 → 清 nextTick → 清 Promise 微任务 → 下一个宏回调

常见误区

  • 以为微任务要等所有阶段跑完才执行:每个阶段间隙都会清空。
  • 在 nextTick 里递归注册 nextTick:微任务队列 starving 事件循环。

追问

  • Node 11 前后行为差别?答:11 起与浏览器对齐,每个宏回调后也清空微任务。
  • nextTick 与 Promise 谁先清空?答:先清空 nextTick 队列,再清空 Promise 微任务队列(见 04.2.1.2)。

04.2.1.1-012 Node 事件循环与浏览器事件循环有什么区别?

一句话结论

两者都是“宏任务 + 微任务”模型,但 Node 按 libuv 阶段组织宏任务队列,浏览器按任务源分类,阶段划分和队列归属不同。

概念解释

浏览器把不同任务源回调放进各自队列,每执行一个宏任务后清空微任务;Node 宏任务拆进六个阶段。API 命名也不同,浏览器没有 process.nextTick。

原理流程

  1. 浏览器:任务源回调入各自队列 → 取一个宏任务执行 → 清空微任务 → 取下一个。
  2. Node:按 timers、pending、idle/prepare、poll、check、close 六阶段推进,阶段间隙清空微任务与 nextTick。
  3. 同一个 setTimeout(fn, 0) 在两边归属不同队列,因此不能直接套用浏览器的先后结论。

代码或图示

维度 Node.js 浏览器
阶段划分 libuv 六阶段 按任务源队列
微任务 nextTick + Promise Promise 等
定时器 timers 阶段 定时器任务源
额外插队 process.nextTick 无对应 API

常见误区

  • 把浏览器队列顺序结论直接套到 Node 顶层代码:宏任务归属不同,顺序推演要按阶段来。
  • 认为浏览器也有 nextTick 同等优先级队列:没有。

追问

  • 两套模型共同点?答:都是宏任务之间批量清空微任务,保证收尾逻辑先执行。
  • 浏览器微任务包含哪些?答:Promise 回调、MutationObserver、queueMicrotask 等;没有 nextTick 对应的插队队列。

04.2.1.1-013 事件循环什么时候退出?

一句话结论

没有待处理句柄、没有到期/待执行定时器、没有待处理异步请求时,事件循环退出,进程结束。

概念解释

Node 进程不会因主线程代码跑完就立刻退出:还有保持存活的句柄时循环继续转。unref() 可让定时器不再单独阻止进程退出。

原理流程

  1. 每轮循环检查句柄集、定时器队列、待处理请求。
  2. 三者都为空时停止循环。
  3. 触发 process.on('exit') 回调后进程结束。

代码或图示

句柄清空 + 定时器清空 + 请求清空 → 退出循环 → exit 事件 → 进程结束

常见误区

  • 以为只要循环空闲就退出:有挂起连接或定时器时继续等待。
  • 用 process.exit() 当常规退出方式:它丢弃在途回调和缓冲。

追问

  • 服务进程为什么一直挂着?答:HTTP server 监听端口就是保持存活的句柄。
  • unref() 有什么用?答:让定时器或句柄不再单独阻止进程退出,只剩它时进程可以正常结束。

04.2.1.1-014 为什么同步 CPU 密集会阻塞事件循环?

一句话结论

JS 回调都在主线程串行执行,长同步计算不主动让出,事件循环无法进入下一阶段,其他定时器、IO 回调和新请求全部排队。

概念解释

事件循环是协作式调度:主线程执行当前代码期间不被抢占。同步循环、大 JSON 解析、复杂正则、大块同步加密都会占住线程。

原理流程

  1. 主线程进入长同步任务。
  2. 期间到达的 IO 事件、定时器到期在队列等待。
  3. 任务结束后循环回到对应阶段批量补跑积压回调。

代码或图示

长同步任务占用主线程 → 回调排队等待 → 任务结束 → 批量补跑

常见误区

  • “异步框架会自动把 CPU 任务切开”:JS 层没有线程抢占,必须拆分或卸载。
  • 阻塞只影响当前请求:单线程被占住时,服务上所有请求回调都延后。

追问

  • 重计算怎么卸载?答:拆小块让出主线程,或交给 worker_threads。
  • 怎么判断主线程被长计算占住?答:事件循环延迟升高、回调排队,可用 monitorEventLoopDelay 观测。

04.2.1.1-015 哪些同步操作会卡住事件循环?

一句话结论

典型阻塞操作:同步 fs API、超大 JSON.parse/stringify、灾难性回溯正则、大块同步加密/压缩、长循环/重计算、主线程处理大图片或大数组遍历。

概念解释

判断标准:是否在主线程连续占用 CPU 或发起阻塞系统调用。网络 IO 回调本身不阻塞,但回调里做重计算会阻塞。

原理流程

  1. 识别操作是否在主线程连续计算或阻塞调用。
  2. 同步 fs、同步加密、大序列化归入阻塞类。
  3. 用异步 API / 卸载 Worker 替换。

代码或图示

阻塞操作清单:同步 fs · 大 JSON · 回溯正则 · 同步加密压缩 · 长循环

常见误区

  • 只要用了 await 就不会阻塞:await 之后的同步计算仍在主线程。
  • 加密库一定异步:需区分流式/异步接口与同步接口。

追问

  • 怎么量化阻塞时长?答:用 monitorEventLoopDelay 测量事件循环延迟(见 04.2.2.5)。
  • 大对象 JSON 解析会卡吗?答:会,JSON.parse/stringify 大对象是同步主线程计算,需分块处理或卸载到 Worker。

04.2.1.1-016 调用栈深度限制与递归风险是什么?

一句话结论

每次函数调用压入调用栈,栈深度超过 V8 限制抛 RangeError: Maximum call stack size exceeded;过深递归应改迭代或分批异步处理。

概念解释

V8 为主线程调用栈设定容量上限。尾递归在 V8 早期有优化,但服务端代码不应依赖尾递归展开。深树/大数组递归容易爆栈。

原理流程

  1. 函数调用压栈,局部变量入帧。
  2. 递归过深栈帧超出容量上限。
  3. 抛栈溢出错误,请求中断。

代码或图示

递归调用 → 栈帧累积 → 超过栈上限 → RangeError

常见误区

  • 把爆栈和内存泄漏混为一谈:爆栈是栈长度超限,对象内存还在堆上。
  • 以为加大堆内存能解决:栈深度限制与堆大小是两套限制。

追问

  • 深树遍历怎么改?答:改迭代(显式栈),或分批用 setImmediate/queueMicrotask 让出主线程。
  • 栈溢出错误长什么样?答:抛出 RangeError: Maximum call stack size exceeded,属栈长度超限,不是堆内存不足。

04.2.1.1-017 进程退出码、uncaughtException 与 exit 事件是什么关系?

一句话结论

未捕获异常默认导致非零退出;uncaughtException 是最后兜底钩子,exit 事件在退出前做同步清理;兜底后应尽快优雅退出。

概念解释

uncaughtException 捕获未被 try/catch 的同步异常;unhandledRejection 对应 Promise 拒绝。捕获后主线程状态可能已损坏,继续运行有不确定性。

原理流程

  1. 异常未被业务捕获 → 触发 uncaughtException 钩子。
  2. 钩子记录现场后按策略退出。
  3. exit 事件执行同步清理,进程结束。

代码或图示

未捕获异常 → uncaughtException 兜底 → 记录/退出 → exit 事件清理

常见误区

  • 在钩子内发异步请求:exit 事件回调执行完进程立即结束,异步来不及完成。
  • 依赖兜底钩子发现 bug:它是安全网,不是常规错误处理路径。

追问

  • Node 15 起未处理 Promise 拒绝默认行为?答:默认抛错并使进程非零退出。
  • process.on('exit') 里能做什么?答:只能做同步清理,如写日志、收尾统计,不能发异步请求。

04.2.1.1-018 libuv 在不同平台用什么 IO 多路复用机制?

一句话结论

Linux 用 epoll,macOS/BSD 用 kqueue,Windows 用 IOCP,libuv 对上层屏蔽这些差异。

概念解释

事件循环的网络等待底层依赖操作系统接口:单进程监听大量连接时,内核通知哪些 socket 就绪,不为每个连接开线程。

原理流程

  1. 网络 socket 注册到对应多路复用接口。
  2. 就绪事件由内核通知。
  3. libuv 回调交给主线程执行。

代码或图示

Linux: epoll │ macOS/BSD: kqueue │ Windows: IOCP ──统一到 libuv 事件循环

常见误区

  • 以为 Node 在 Windows 上也用 epoll:Windows 对应 IOCP,模型细节不同。
  • 认为多路复用机制决定 JS 单线程:它只影响内核通知方式。

追问

  • 为什么文件 IO 不直接走多路复用?答:文件系统阻塞语义,文件 IO 交给线程池(见 04.2.1.3)。
  • macOS 用什么多路复用机制?答:macOS/BSD 用 kqueue,Linux 用 epoll,Windows 用 IOCP。
  • 为什么文件 IO 不直接走多路复用?答:文件系统阻塞语义,文件 IO 交给线程池(见 04.2.1.3)。