# 垃圾回收：垃圾数据如何自动回收|浏览器篇

> 本文系统介绍了浏览器中垃圾回收的原理与机制，比较了手动与自动垃圾回收策略，重点解析了 JavaScript 如何自动管理和回收内存，帮助开发者理解内存泄漏及优化前端性能的方法。

- 原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/13-%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%EF%BC%9A%E5%9E%83%E5%9C%BE%E6%95%B0%E6%8D%AE%E5%A6%82%E4%BD%95%E8%87%AA%E5%8A%A8%E5%9B%9E%E6%94%B6
- 来源：前端进阶之旅（feinterview.poetries.top）
- 更新：2026.10.03
- 可见范围：免费部分

---

## 垃圾回收：垃圾数据如何自动回收

- 垃圾数据 = 用完了、以后再也用不到的数据，不清掉内存只会越用越多
- 判断标准是可达性：从根（调用栈变量、全局对象、宿主持有的引用）顺着引用找不到的就是垃圾
- 函数返回 ≠ 里面的对象都成了垃圾，被全局、闭包、监听器拿着的还活着
- 互相引用但外面没人引用的一组对象，同样会被回收（标记清除不怕环）
- 回收时机由引擎决定，断开引用不等于立刻释放

**垃圾回收就是把以后再也用不到的数据找出来，把它占的内存腾出来。** 怎么判断用不到？看能不能从根出发顺着引用找到它。根就是当前调用栈里的变量、`window` 这种全局对象、浏览器自己持有的东西。比如一个函数创建了 `1000` 条记录，返回后这些记录就没人能访问了，可以回收；但只要有一条被塞进了 `globalThis.savedRecord`，那条就还活着。断开引用之后也不是马上释放，具体什么时候收由引擎决定。

有些数据被使用之后，可能就不再需要了，我们把这种数据称为垃圾数据。如果这些垃圾数据一直保存在内存中，那么内存会越用越多，所以我们需要对这些垃圾数据进行回收，以释放有限的内存空间

**原理拆解：** 垃圾并不等同于“函数已经执行完”或“变量离开了局部作用域”，更准确的判断依据是数据是否仍能从程序的根集合沿引用关系到达。根通常包括当前调用栈中的变量、全局对象及宿主环境保留的引用。只要存在一条有效引用链，对象仍可能被后续代码使用；当所有引用链都断开时，它才具备被回收的条件。回收器随后识别不可达对象并重新利用其内存，但回收时机由引擎决定。

**最小验证：** 输入一批临时对象，只把其中一个保存到全局变量中，用来验证“是否保留引用”比“是否执行完函数”更关键。

```javascript
function createRecords() {
  const records = Array.from({ length: 1000 }, (_, id) => ({
    id,
    payload: new Array(100).fill(id)
  }));

  globalThis.savedRecord = records[0];
  return records.length;
}

console.log(createRecords());
console.log(globalThis.savedRecord.id);
globalThis.savedRecord = null;
```

`records` 在函数返回后不再可访问，其中未被保存的对象具备回收条件；`savedRecord` 指向的对象仍可从 `globalThis` 到达，所以第二次输出为 `0`。最后赋值为 `null` 才切断这条引用链。代码只能制造并观察引用关系，不能保证垃圾回收立即发生，也不能通过一次内存读数证明对象已经释放。

**边界与排查：** 定时器回调、事件监听器、闭包、缓存容器和未结束的异步任务都可能间接持有对象。排查持续增长的内存时，可在 `Chrome DevTools` 的 `Memory` 面板中分别获取操作前后的堆快照，重复目标操作后比较对象数量与保留路径；若对象仍能沿 `Window`、监听器或闭包到达，应先解除对应引用，而不是依赖手动触发回收。

- **函数里创建 `1000` 条记录然后返回，所有记录都成垃圾了吗？**

  不一定。有一条被存到 `globalThis.savedRecord` 的话，它从全局对象可达，就不是垃圾。其他 `999` 条没人引用，才具备回收条件。

- **两个对象互相引用，是不是就永远回收不了？**

  不是，那是引用计数的老问题。现代引擎用标记清除，从根出发标记，外面没人引用的环整个都标不到，照样回收。

- **切换详情页 `200` 次后堆一直涨，负责人要求退出时把所有局部变量设 `null`，有用吗？**

  基本没用，局部变量函数一返回就没了。真正的问题通常在长期持有者：全局 `Map`、没清的 `setInterval`、没 `removeEventListener` 的监听、没取消的请求回调。拍两张快照对比，看 `Retainers` 找到它。

- **移除了 `DOM` 节点，节点关联的数据对象却越来越多，为什么？**

  节点从页面上拿掉了，但如果 `JS` 里还有变量或者闭包引用着它，它就成了 `Detached` 节点，连带关联数据都回收不了。堆快照里搜 `Detached` 能直接看到。

- **全局缓存用 `Map` 存对象，要求永久保留，能指望 `GC` 帮忙释放吗？**

  不能，`Map` 还引用着，从根可达就不是垃圾。要么设上限做 `LRU` 淘汰；如果键是对象、想让它随键一起消失，用 `WeakMap`。

## 不同语言的垃圾回收策略

- 两种策略：手动回收（`C/C++` 的 `malloc` / `free`）和自动回收（`JS`、`Java`、`Python`）
- 手动：申请了忘记 `free` = 内存泄漏；`free` 了还接着用 = 野指针，更危险
- 自动：垃圾回收器负责释放，但「还被引用」的东西它不会动
- 自动回收不等于不用管内存，`JS` 里的泄漏全是「不该引用的还引用着」
- `JS` 数据存在栈和堆，两块的回收方式不同，下一节分开讲

**垃圾回收分手动和自动两种：`C/C++` 自己 `malloc` 申请、`free` 释放，`JS`、`Java`、`Python` 交给垃圾回收器。** 手动的好处是时机完全可控，坏处是容易出错，申请了忘记 `free` 就泄漏，`free` 了还接着用更危险。自动回收省掉了这些麻烦，但很多人因此觉得 `JS` 不用管内存，这是个误解。回收器只回收没人引用的数据，你把对象塞进全局数组、忘了清定时器，它照样一直占着内存。`JS` 的内存泄漏，说白了就是不该引用的东西还被引用着。

通常情况下，垃圾数据回收分为手动回收和自动回收两种策略。

如 C/C++ 就是使用手动回收策略，何时分配内存、何时销毁内存都是由代码控制的，你可以参考下面这段 C 代码：

```c
// 在堆中分配内存
char* p =  (char*)malloc(2048);  // 在堆空间中分配 2048 字节的空间，并将分配后的引用地址保存到 p 中

 // 使用 p 指向的内存
 {
   //....
 }

// 使用结束后，销毁这段内存
free(p)；
p = NULL；
```

从上面这段 C 代码可以看出来，要使用堆中的一块空间，我们需要先调用 mallco 函数分配内存，然后再使用；当不再需要这块数据的时候，就要手动调用 free 函数来释放内存。如果这段数据已经不再需要了，但是又没有主动调用 free 函数来销毁，那么这种情况就被称为内存泄漏。

另外一种使用的是自动垃圾回收的策略，如 JavaScript、Java、Python 等语言，产生的垃圾数据是由垃圾回收器来释放的，并不需要手动通过代码来释放。

对于 JavaScript 而言，也正是这个“自动”释放资源的特性带来了很多困惑，也让一些 JavaScript 开发者误以为可以不关心内存管理，这是一个很大的误解。

那么在本文，我们将围绕“JavaScript 的数据是如何回收的”这个话题来展开探讨。因为数据是存储在栈和堆两种内存空间中的，所以接下来我们就来分别介绍“栈中的垃圾数据”和“堆中的垃圾数据”是如何回收的。

- **一个 `C` 函数 `malloc(2048)` 后，正常路径 `free(p)`，错误分支提前 `return` 了，长期运行会怎样？**

  每走一次错误分支就漏 `2KB`，服务跑久了内存越来越高。`C` 里常见的写法是统一用 `goto cleanup` 收口，`C++` 用 `RAII` 或智能指针让析构自动释放。

- **`JS` 有自动回收，那缓存从 `1000` 项放开到无限增长也没关系吧？**

  有关系。缓存还引用着的条目，回收器一个都不会碰，无限增长就是内存泄漏。要设容量上限或者过期时间，比如做个 `LRU`。

- **页面跑几小时崩了，排查的人认定是 `V8` 垃圾回收出了问题，你会先查什么？**

  先查自己的代码。重复操作后对比堆快照，看增长的对象被谁引用着，十有八九是全局缓存、定时器、监听器或闭包。对象明明不可达还在累积，才轮得到怀疑引擎。

- **`JS` 里有没有办法手动触发 `GC`？**

  页面代码里没有标准办法。`Node.js` 用 `--expose-gc` 启动能调 `global.gc()`，`DevTools` 的 `Memory` 面板也有个垃圾桶按钮，但都只用于调试，业务里该做的是断开引用。

- **从 `C` 迁到 `JS` 的图像处理逻辑，想保留 `free(p)` 式的接口，可行吗？**

  `JS` 里没有真正的 `free`，最多是个把引用置空的 `dispose()`，内存什么时候还给系统还是引擎说了算。大块数据要控峰值，就分批处理、复用同一个 `ArrayBuffer`，别一次全读进内存。

## 调用栈中的数据是如何回收的

- 调用栈回收靠挪指针：函数返回 → `ESP` 下移到调用者的执行上下文 → 这一帧就作废了
- 作废 ≠ 清零：旧字节还留在内存里，下一次函数调用直接覆盖
- 所以栈上回收几乎零成本，不需要垃圾回收器参与
- 栈帧没了只代表那条局部引用没了，它指向的堆对象还得 `GC` 按可达性判断
- 别在函数结尾把局部变量挨个设 `null`，对栈没意义

**调用栈上的数据不用垃圾回收器管，函数一返回，引擎把 `ESP` 指针挪回调用者那一帧，当前这帧就算销毁了。** 打个比方，栈像一摞草稿纸，用完不撕，只是把「当前页」的书签往回翻一页，下次写东西直接盖在上面。比如 `foo` 里调 `showName`，`showName` 跑完 `ESP` 回到 `foo`，`showName` 的变量 `c`、`d` 虽然还躺在内存里，但已经是无效区域。要分清的是：`d` 只是栈上的一个引用，它指向的那个对象在堆里，栈帧没了不代表堆对象就没了。

首先是调用栈中的数据，我们还是通过一段示例代码的执行流程来分析其回收机制，具体如下：

```js
function foo(){
    var a = 1
    var b = {name:" 极客邦 "}
    function showName(){
      var c = " 极客时间 "
      var d = {name:" 极客时间 "}
    }
    showName()
}
foo()
```

当执行到第 6 行代码时，其调用栈和堆空间状态图如下所示：

![](https://s.poetries.top/gitee/2019/11/10.png)

从图中可以看出，原始类型的数据被分配到栈中，引用类型的数据会被分配到堆中。当 foo 函数执行结束之后，foo 函数的执行上下文会从堆中被销毁掉，那么它是怎么被销毁的呢？下面我们就来分析一下。

在上篇文章中，我们简单介绍过了，如果执行到 showName 函数时，那么 JavaScript 引擎会创建 showName 函数的执行上下文，并将 showName 函数的执行上下文压入到调用栈中，最终执行到 showName 函数时，其调用栈就如上图所示。与此同时，还有一个记录当前执行状态的指针（称为 ESP），指向调用栈中 showName 函数的执行上下文，表示当前正在执行 showName 函数。

接着，当 showName 函数执行完成之后，函数执行流程就进入了 foo 函数，那这时就需要销毁 showName 函数的执行上下文了。ESP 这时候就帮上忙了，JavaScript 会将 ESP 下移到 foo 函数的执行上下文，这个下移操作就是销毁 showName 函数执行上下文的过程。

你可能会有点懵，ESP 指针向下移动怎么就能把 showName 的执行上下文销毁了呢？具体你可以看下面这张移动 ESP 前后的对比图

![](https://s.poetries.top/gitee/2019/11/11.png)

从图中可以看出，当 showName 函数执行结束之后，ESP 向下移动到 foo 函数的执行上下文中，上面 showName 的执行上下文虽然保存在栈内存中，但是已经是无效内存了。比如当 foo 函数再次调用另外一个函数时，这块内容会被直接覆盖掉，用来存放另外一个函数的执行上下文。

所以说，当一个函数执行结束之后，JavaScript 引擎会通过向下移动 ESP 来销毁该函数保存在栈中的执行上下文。

- **函数结尾把局部变量全设成 `null`，能让栈空间释放得更快吗？**

  不能。函数一返回整帧就失效了，设 `null` 纯属多写几行。真正值得手动断开的是被闭包、全局变量、长期缓存持有的引用，那是堆的问题，不是栈的。

- **内存快照里还能搜到已返回函数里的字符串，算不算栈泄漏？**

  不算。`ESP` 已经回退，那块区域只是还没被覆盖，下一次调用就会写掉。字符串本身在堆上的话，要看 `Retainers` 里还有没有人引用它，有人引用才叫泄漏。

- **递归 `10000` 层报 `Maximum call stack size exceeded`，这跟回收有关系吗？**

  没关系，是调用过程中栈帧压得太深，栈空间就那么点（`V8` 默认 `1MB` 左右量级），还没轮到返回回收就爆了。改成循环、显式用数组模拟栈，或者拆成异步分片。

- **`foo` 里 `var b = { name: 'x' }`，`foo` 返回后这个对象立刻被删了吗？**

  不是立刻。`foo` 返回只是让 `b` 这条引用消失，对象变成不可达，要等下一次 `GC` 扫到它才回收。如果 `b` 之前被塞进了全局数组或事件回调，那它压根不会被回收。

- **为什么栈能这么回收，堆不行？**

  栈是严格后进先出的，谁先结束谁就在最上面，挪一下指针就行。堆上的对象生命周期互相交错，谁还在用只能靠从根出发遍历引用去判断，所以需要垃圾回收器。

## 堆中的数据是如何回收的

- 函数返回后栈帧作废，但它创建的对象还占着堆，这部分要交给 `V8` 的垃圾回收器
- 判断标准是可达性：从根（全局对象、当前调用栈、`DOM` 等宿主引用）出发能走到的就是活的
- 循环引用不等于泄漏，整个环从根走不到照样回收（引用计数才怕环）
- 真泄漏通常是意外的根引用：全局数组越积越多、监听器没解绑、`Map` 缓存只进不出
- 排查用 `Memory` 面板拍多次堆快照对比，看 `Retainers` 链最后连到谁

---

> 以上是免费部分。完整内容需要「前端进阶之旅」会员，原文：https://feinterview.poetries.top/docs/fe-base-docs/browser/part3/13-%E5%9E%83%E5%9C%BE%E5%9B%9E%E6%94%B6%EF%BC%9A%E5%9E%83%E5%9C%BE%E6%95%B0%E6%8D%AE%E5%A6%82%E4%BD%95%E8%87%AA%E5%8A%A8%E5%9B%9E%E6%94%B6
