JS `Garbage Collection` `Generational` / `Incremental` / `Concurrent` / `Parallel` `GC` 算法的权衡与调优

各位观众老爷们，晚上好！我是你们的老朋友，今天咱们来聊聊JavaScript垃圾回收（GC）的那些事儿。别害怕，GC听起来高大上，其实就是帮我们自动清理内存，让程序跑得更顺畅。咱们今天就把它扒个底朝天，看看它的各种算法、权衡、调优，保证让你听得懂，用得上。

一、垃圾回收，你不得不了解的“幕后英雄”

想象一下，你写了一大堆代码，创建了一堆对象，用完了就扔。如果没有人打扫卫生，内存很快就被垃圾塞满了，程序就卡死了。这时候，GC就闪亮登场了，它负责自动找到这些“垃圾”，并把它们清理掉，释放内存。

简单来说，GC干的就是两件事：

找到垃圾： 找出不再使用的对象。
清理垃圾： 释放这些对象占用的内存。

二、 GC算法：各有千秋，各有所长

JS引擎（比如V8）使用了很多种GC算法，每种算法都有自己的优缺点。我们来看看几个常见的：

标记-清除（Mark and Sweep）： 这是最基础的GC算法。

标记阶段： 从根对象（比如全局对象）开始，递归地遍历所有可达的对象，并给它们打上标记。
清除阶段： 遍历整个内存空间，清除所有没有标记的对象。

// 模拟标记-清除过程
let obj1 = { a: 1 };
let obj2 = { b: 2 };
obj1.c = obj2; // obj1引用obj2

// 假设根对象是 global
let global = { obj1: obj1 };

// 标记阶段 (伪代码)
function mark(obj) {
    if (obj.marked) return; // 已经标记过了
    obj.marked = true;
    for (let key in obj) {
        if (typeof obj[key] === 'object' && obj[key] !== null) {
            mark(obj[key]); // 递归标记引用的对象
        }
    }
}

mark(global); // 从根对象开始标记

// 清除阶段 (伪代码)
function sweep() {
    for (let address in memory) { // 遍历内存
        let obj = memory[address];
        if (obj && !obj.marked) {
            // 清除未标记的对象
            delete memory[address];
        } else if (obj) {
            delete obj.marked; // 清除标记，为下次GC做准备
        }
    }
}

sweep();

优点： 实现简单。
缺点： 会产生内存碎片，而且需要暂停整个程序（Stop-the-World，STW）。

标记-整理（Mark and Compact）： 在标记-清除的基础上进行了优化。
- 标记阶段： 和标记-清除一样。
- 整理阶段： 将所有存活的对象移动到内存的一端，然后直接清除边界以外的内存。
优点： 可以消除内存碎片。
缺点： 移动对象需要花费更多时间，STW时间更长。
引用计数（Reference Counting）： 每个对象都有一个引用计数器，当对象被引用时，计数器加1，当引用失效时，计数器减1。当计数器为0时，对象就可以被回收了。
```
// 模拟引用计数
let obj1 = { a: 1 };
obj1.refCount = 1; // 引用计数初始化为1

let obj2 = obj1;
obj1.refCount++; // obj2引用了obj1，计数器加1

obj1 = null;
obj2.refCount--; // obj1不再引用，计数器减1

if (obj2.refCount === 0) {
    // 可以回收obj2了
    obj2 = null;
}
```
优点： 实现简单，可以及时回收垃圾。
缺点： 无法处理循环引用，开销较大。

三、高级GC算法：为了更流畅的体验

为了解决基础GC算法的缺点，JS引擎引入了一些高级GC算法：

分代回收（Generational GC）： 基于一个假设：大多数对象很快就会变成垃圾。因此，将内存分为几个代（通常是新生代和老生代），对不同代的对象采用不同的GC策略。
- 新生代（Young Generation）： 存放新创建的对象。通常采用快速的GC算法，比如Scavenge算法。
- 老生代（Old Generation）： 存放存活时间较长的对象。通常采用复杂的GC算法，比如标记-清除或标记-整理。
新生代GC（Scavenge算法）：
1. 将新生代分为两个区域：From Space和To Space。
2. 新对象分配到From Space。
3. GC时，将From Space中存活的对象复制到To Space。
4. From Space和To Space互换角色。
优点： 可以提高GC效率，减少STW时间。
缺点： 需要额外的内存空间。
增量式GC（Incremental GC）： 将GC过程分成多个小步骤，每次只处理一部分对象，而不是一次性处理所有对象。这样可以减少STW时间，提高程序的响应性。
并发式GC（Concurrent GC）： GC线程和主线程可以同时运行。GC线程在后台扫描和清理垃圾，而主线程继续执行代码。这样可以最大程度地减少STW时间。
并行式GC（Parallel GC）： 使用多个GC线程同时进行垃圾回收。可以提高GC效率，缩短STW时间。

四、 GC算法的权衡：没有银弹

不同的GC算法各有优缺点，选择哪种算法取决于具体的应用场景。

算法	优点	缺点	适用场景
标记-清除	实现简单	产生内存碎片，STW时间较长	内存占用不高，对响应时间要求不高的应用
标记-整理	消除内存碎片	移动对象需要时间，STW时间较长	内存碎片较多，需要整理内存的应用
引用计数	实现简单，及时回收垃圾	无法处理循环引用，开销较大	简单的对象关系，对内存占用要求不高的应用
分代回收	提高GC效率，减少STW时间	需要额外的内存空间	大部分Web应用，对象生命周期有明显差异的应用
增量式GC	减少STW时间，提高程序响应性	实现复杂	对响应时间要求高的应用，比如动画、游戏
并发式GC	最大程度地减少STW时间	实现非常复杂，需要考虑线程同步问题	对响应时间要求非常高的应用，比如实时系统
并行式GC	提高GC效率，缩短STW时间	需要多核CPU支持	服务器端应用，拥有多核CPU，需要处理大量数据的应用

五、 GC调优：让你的程序飞起来

虽然GC是自动的，但我们仍然可以通过一些技巧来优化GC性能：

避免创建不必要的对象： 对象创建越多，GC压力越大。尽量复用对象，避免在循环中创建大量临时对象。

// 不好的写法
for (let i = 0; i < 10000; i++) {
    let obj = { a: i }; // 每次循环都创建一个新对象
    // ...
}

// 好的写法
let obj = {};
for (let i = 0; i < 10000; i++) {
    obj.a = i; // 复用同一个对象
    // ...
}

及时释放不再使用的对象： 将不再使用的对象设置为null，可以帮助GC更快地回收它们。

function processData() {
    let data = loadData(); // 加载数据
    // ... 使用data
    data = null; // 释放data
}

避免循环引用： 循环引用会导致对象无法被GC回收，造成内存泄漏。

let obj1 = {};
let obj2 = {};
obj1.a = obj2;
obj2.b = obj1; // 循环引用

// 解决循环引用
obj1.a = null;
obj2.b = null;

使用WeakMap和WeakSet： WeakMap和WeakSet允许你创建对对象的弱引用。当对象不再被其他地方引用时，即使WeakMap或WeakSet仍然持有对它的引用，对象仍然可以被GC回收。
```
let map = new WeakMap();
let element = document.getElementById('myElement');
map.set(element, { data: 'some data' });

// 当element从DOM中移除时，WeakMap中的键值对也会被自动清理
```
减少全局变量的使用： 全局变量会一直存在于内存中，直到程序退出。尽量使用局部变量，减少全局变量的数量。

使用对象池： 如果需要频繁创建和销毁相同类型的对象，可以使用对象池来复用对象，减少GC压力。

class Bullet {
    constructor() {
        this.active = false;
        // ... 其他属性
    }

    init() {
        this.active = true;
        // ... 初始化
    }

    reset() {
        this.active = false;
        // ... 重置
    }
}

class BulletPool {
    constructor(size) {
        this.pool = [];
        for (let i = 0; i < size; i++) {
            this.pool.push(new Bullet());
        }
    }

    getBullet() {
        for (let i = 0; i < this.pool.length; i++) {
            let bullet = this.pool[i];
            if (!bullet.active) {
                bullet.init();
                return bullet;
            }
        }
        // 如果池中没有空闲的子弹，可以考虑扩展池子
        return null;
    }

    releaseBullet(bullet) {
        bullet.reset();
    }
}

let bulletPool = new BulletPool(100);
let bullet = bulletPool.getBullet();
// ... 使用子弹
bulletPool.releaseBullet(bullet);

使用性能分析工具： Chrome DevTools等工具可以帮助你分析程序的内存使用情况，找出内存泄漏和GC瓶颈。

六、总结：掌握GC，掌控性能

GC是JS引擎的重要组成部分，了解GC的原理和调优技巧，可以帮助我们编写更高效、更稳定的代码。虽然GC是自动的，但我们仍然可以通过一些技巧来优化GC性能，让我们的程序飞起来。

记住，没有银弹。选择合适的GC策略并进行适当的调优，才能达到最佳的性能。

好了，今天的讲座就到这里。希望大家有所收获，下次再见！

发表回复 取消回复

发表回复取消回复