带你了解，垃圾回收机制

最新推荐文章于 2025-05-20 18:38:36 发布

原创最新推荐文章于 2025-05-20 18:38:36 发布 · 1.3k 阅读

31 ·

CC 4.0 BY-SA版权

文章标签：

#前端 #javascript

一、垃圾回收机制的基本概念

为什么需要垃圾回收？ 在程序运行过程中，计算机需要为对象分配内存。当这些对象不再被使用时，其占用的内存应该被释放，否则会导致内存泄漏，进而影响系统性能甚至引发程序崩溃。如果完全依赖开发者手动释放内存，容易出现以下问题：

- 忘记释放内存，导致内存泄漏。
- 误释放仍在使用的内存，导致悬挂指针或程序崩溃。

垃圾回收机制的作用：通过自动检测哪些内存对象已不再被程序使用，并将它们回收，避免上述问题。

GC 的核心任务：

- 检测垃圾对象：判断哪些对象已经不再被使用。
- 释放内存：回收垃圾对象占用的内存，使其可以被重新分配。

GC 的运行方式：

- 垃圾回收通常在程序运行过程中由垃圾回收器（Garbage Collector）自动执行。

二、垃圾回收的常见算法

为了高效完成内存回收，垃圾回收器设计了多种算法，主要包括以下几种：

引用计数算法：

- 当声明了一个变量并且将一个引用类型赋值给该变量的时候这个值的引用次数就为 1。
- 如果同一个值又被赋给另一个变量，那么引用数加 1。
- 如果该变量的值被其他的值覆盖了，则引用次数减 1。
- 当这个值的引用次数变为 0 的时候，说明没有变量在使用，这个值没法被访问了，回收空间，垃圾回收器会在运行的时候清理掉引用次数为 0 的值占用的内存

优点：引用计数算法的优点我们对比标记清除来看就会清晰很多，首先引用计数在引用值为 0 时，也就是在变成垃圾的那一刻就会被回收，所以它可以立即回收垃圾。

缺点：计数器占很大的位置，无法解决循环引用无法回收的问题。

标记清除算法：

- 对于每个被访问到的对象，垃圾回收器会给它打上标记，表示该对象是可达的，即不是垃圾。这个过程确保了所有可达对象都会被标记。
- 垃圾回收器会遍历整个内存，对于没有标记的对象，即被判定为垃圾的对象，会被立即回收，释放内存空间。这样，只有被标记的对象会被保留在内存中，而垃圾对象会被清除。

优点：标记-清除算法相对简单，容易实现。它可以准确地找到不再被引用的对象，并回收内存。

缺点：标记-清除算法会暂停程序的执行，进行垃圾回收操作，标记-清除算法会在回收过程中产生大量的不连续的、碎片化的内存空间。

分代回收算法（Generational Garbage Collection）：

- 基于“对象生命周期假设”：大多数对象的生命周期很短，只有少数对象会长期存活。
- 将内存分为新生代（短生命周期对象）和老生代（长生命周期对象），分别使用不同的算法回收。

优点：提升了垃圾回收效率，是现代垃圾回收器的核心策略。

三、垃圾回收机制的优缺点

优点：

简化内存管理：开发者无需手动释放内存，大大降低了编程复杂度。
减少错误：有效避免内存泄漏、悬挂指针等常见内存问题。
提高程序稳定性：通过自动管理内存，提升了程序运行的安全性。

缺点：

性能开销：垃圾回收器需要消耗一定的计算资源，会导致程序性能下降。
不可预测性：垃圾回收的触发时间和执行过程通常是不可预测的，可能导致应用程序暂停（Stop-The-World）。
复杂性：优化垃圾回收器需要权衡内存使用效率、回收时间和暂停时间等多个因素，增加了实现难度。

四、垃圾是怎样产生的？

1. 局部变量超出作用域

当函数执行完毕后，函数内部定义的局部变量会超出作用域。如果这些变量不再被其他地方引用，它们所占用的内存会被视为垃圾。

示例：

function createData() {
    let data = { key: "value" }; // data 是一个局部变量
}
createData();
// 当函数执行结束后，data 超出作用域且没有被外部引用，其内存会被回收

垃圾产生：当 createData 执行结束时，局部变量 data 被销毁，内存中的 { key: "value" } 对象如果没有其他引用，将被回收。

2. 变量被重新赋值

当变量被重新赋值时，旧的引用会被覆盖。如果旧对象没有其他引用，则它成为垃圾。

示例：

let A = { name: "jerry" }; // obj 指向一个对象
A = [a,b,c,d]; // 原对象 { name: "jerry" } 没有引用，成为垃圾

垃圾产生：a 指向新的对象 [a,b,c,d]，原来的 { name: "jerry" } 不再被引用，因此会被回收。

3. DOM 元素被移除或替换

当 DOM 元素被移除或替换时，旧的 DOM 节点如果没有其他引用，也会变成垃圾。

示例：

let element = document.getElementById("myDiv");
document.body.removeChild(element); // 删除了 DOM 节点

如果 element 没有被其他变量引用，则相关内存会被释放。

垃圾产生：element 对应的 DOM 节点已从文档中移除，且无其他引用，将成为垃圾。

4. 闭包导致的未被释放的内存

如果闭包中引用了不需要的变量，且未及时解除引用，则这些变量可能无法被回收。

示例：

function outerFunction() {
    let largeData = new Array(100000).fill("data");
    return function innerFunction() {
        console.log("Using closure");
    };
}
let closure = outerFunction();

- 垃圾未释放：largeData 被 innerFunction 间接引用，导致无法被回收，即使它已无用。
- 解决方法：显式将无用变量设为 null，如 largeData = null;。

5. 循环引用

前端开发中，循环引用是产生垃圾的常见原因，尤其在对象或 DOM 节点之间。

示例：

let obj1 = {};
let obj2 = {};
obj1.ref = obj2;
obj2.ref = obj1; // 两个对象互相引用
obj1 = null;
obj2 = null; // 互相引用的对象没有外部引用，变为垃圾

垃圾产生：obj1 和 obj2 互相引用，形成循环引用，但没有其他外部引用它们，因此垃圾回收器会回收它们。

6. 事件监听未正确清除

当事件监听器绑定在某个 DOM 节点上，而节点被删除时，如果监听器没有被移除，则会导致内存泄漏和垃圾堆积。

示例：

let button = document.getElementById("myButton");
button.addEventListener("click", function handleClick() {
    console.log("Button clicked");
});
document.body.removeChild(button); // 移除 button，但事件监听器仍然存在

垃圾未释放：虽然 button 已被移除，但其事件监听器仍然存在，导致按钮占用的内存无法被回收。
解决方法：在移除 DOM 元素前，手动移除监听器，如 button.removeEventListener("click", handleClick);。

五、为什么要进行垃圾回收？

1. 限制内存占用，避免内存泄漏

原因：前端代码运行在浏览器中，而浏览器的内存资源是有限的。如果程序不断占用内存而不释放，会导致内存泄漏，最终可能导致性能下降，甚至浏览器崩溃。
垃圾回收作用：通过自动检测不再使用的对象，将其占用的内存释放，从而防止内存占用持续增长。
示例：

javascript


复制代码
function createData() {
    let largeArray = new Array(100000).fill("data"); // 创建一个大数组
    return largeArray;
}

createData();
// 如果不需要该数组，垃圾回收器会回收其内存，避免占用资源

2. 简化内存管理，减少开发难度

原因：手动管理内存（如手动分配和释放内存）会增加代码复杂性，并容易导致内存泄漏或悬挂指针等问题。尤其在复杂的单页应用（SPA）中，手动追踪和释放所有不需要的资源几乎是不现实的。
垃圾回收作用：通过自动检测哪些对象不再被使用，开发者无需显式释放内存，降低了编程难度，提升代码的可维护性。
对比：

- 手动内存管理（如 C 语言）：开发者需要明确分配和释放内存，容易导致问题。
- 自动垃圾回收（如 JavaScript）：垃圾回收器会根据对象的可达性，自动释放内存，简化了工作。

3. 提高程序性能，保证用户体验

原因：如果没有垃圾回收，内存的长期占用会导致程序性能逐渐下降。例如，在处理大量 DOM 操作、动态加载数据或频繁执行事件监听时，未释放的内存会拖慢页面渲染速度，甚至导致浏览器变卡或无响应。
垃圾回收作用：通过释放不再使用的内存，确保程序性能维持在较高水平，提升用户体验。

六、垃圾回收是怎样进行的？

1. 标记-清除算法（Mark-and-Sweep）

这是 JavaScript 中最基础、最常用的垃圾回收算法。

步骤：

1. 标记阶段：从根对象出发，遍历所有可达对象，并做标记。
2. 清除阶段：未被标记的对象会被认为是不可达的，回收其内存。

示例：

let obj1 = { name: "Alice" };
let obj2 = { name: "Bob" };
obj1.friend = obj2; // obj1 引用了 obj2
obj2 = null; // obj2 被置为 null，但 obj1 仍引用它，所以不会被回收

obj1 = null; // 此时 obj1 和 obj2 都不可达，将被垃圾回收

优点：简单高效，适合大多数场景。
缺点：可能会在标记阶段暂停程序执行，影响性能，其次，清除之内剩余的内存位置不会变，导航空闲内存不连续，出现了内存碎片，如图，然后内存不是一整块，会导致内存分配问题。

2. 引用计数（Reference Counting）

这种算法通过统计对象被引用的次数来判断对象是否可以回收。

原理：

1. 每个对象有一个引用计数器，记录被引用的次数。
2. 引用计数为 0 的对象会被认为是垃圾，释放内存。
3. 当对象的引用增加或减少时，更新计数。

示例：

let obj1 = { name: "Alice" };
let obj2 = obj1; // obj1 的引用计数为 2
obj1 = null; // obj1 的引用计数为 1
obj2 = null; // obj1 的引用计数为 0，对象被回收

缺点：无法处理循环引用。

let obj1 = {};
let obj2 = {};
obj1.ref = obj2;
obj2.ref = obj1;

obj1 = null;
obj2 = null; // 虽然两者都不可达，但互相引用，导致无法被回收

3. 分代回收（Generational Garbage Collection）

现代 JavaScript 引擎（如 V8 引擎）结合了标记-清除和分代回收来提升效率。

核心思想：根据对象的生命周期将其划分为不同的代（generation），分别处理：

- 新生代（Young Generation）：生命周期较短的对象，如局部变量、临时对象。
- 老生代（Old Generation）：生命周期较长的对象，如全局变量、闭包引用的变量。

工作流程：

1. 新生代垃圾回收：采用快速、轻量的算法，如复制算法（Copying Collection）。将仍然存活的新生代对象复制到另一块内存空间，不再存活的对象被释放。
2. 老生代垃圾回收：采用标记-清除算法，对老生代对象进行垃圾回收。
3. 新生代对象在多次回收后仍存活，会被移动到老生代。