JavaScript垃圾回收机制全面解析与实战避坑指南

为啥要对比这几个垃圾回收方案

垃圾回收（Garbage Collection，简称GC）是前端开发中一个非常重要的概念，尤其是对于那些需要处理大量数据和复杂逻辑的应用。在JavaScript中，垃圾回收机制是由浏览器自动管理的，但不同的浏览器有不同的实现方式，有时候也会带来一些性能问题。今天我想聊一聊几种主流的垃圾回收方案，并分享一下我在实际项目中的使用体验。

常见的垃圾回收算法

在深入讨论之前，我们先简单了解一下几种常见的垃圾回收算法：

• 标记-清除（Mark and Sweep）：这是最基础的垃圾回收算法，通过标记所有存活的对象，然后清除未被标记的对象来回收内存。
• 引用计数（Reference Counting）：每个对象都有一个引用计数器，当有其他对象引用它时，计数器加一；当引用被释放时，计数器减一。当计数器为零时，对象可以被回收。
• 分代收集（Generational Collection）：将内存分为新生代和老年代，根据对象的生命周期采用不同的回收策略。新生代对象生命周期较短，频繁进行垃圾回收；老年代对象生命周期较长，较少进行垃圾回收。

谁更灵活？谁更省事？

在实际项目中，我比较喜欢用分代收集的方式，因为它可以根据对象的生命周期来进行高效的内存管理。下面我分别介绍一下这几种算法的具体代码和用法。

标记-清除算法

标记-清除算法是最基础的，也是最容易理解的。它的核心思想就是通过标记所有存活的对象，然后清除未被标记的对象来回收内存。

function markAndSweep() {
  const objects = {}; // 假设这是一个全局对象池
  const marked = new Set(); // 用于标记存活的对象

  function mark(obj) {
    if (marked.has(obj)) return;
    marked.add(obj);
    for (let key in obj) {
      if (typeof obj[key] === 'object') {
        mark(obj[key]);
      }
    }
  }

  function sweep() {
    for (let key in objects) {
      if (!marked.has(objects[key])) {
        delete objects[key];
      }
    }
    marked.clear();
  }

  // 标记根对象
  mark(globalObject);

  // 清除未被标记的对象
  sweep();
}

// 示例调用
markAndSweep();

这个算法的优点是简单直观，缺点是在标记和清除过程中可能会导致程序暂停（Stop-the-World），特别是在大数据量的情况下。

引用计数算法

引用计数算法通过维护每个对象的引用计数器来判断对象是否可以被回收。每增加一个引用，计数器加一；每减少一个引用，计数器减一。当计数器为零时，对象可以被回收。

class RefCounting {
  constructor() {
    this.objects = {};
    this.references = {};
  }

  createObject(id, data) {
    this.objects[id] = data;
    this.references[id] = 0;
  }

  addRef(id) {
    if (this.references[id] !== undefined) {
      this.references[id]++;
    }
  }

  removeRef(id) {
    if (this.references[id] !== undefined && this.references[id] > 0) {
      this.references[id]--;
      if (this.references[id] === 0) {
        delete this.objects[id];
      }
    }
  }
}

// 示例调用
const refCounter = new RefCounting();
refCounter.createObject('obj1', { name: 'Alice' });
refCounter.addRef('obj1');
refCounter.removeRef('obj1'); // 对象被回收

引用计数算法的优点是不会导致程序暂停，缺点是无法处理循环引用的问题。这也是为什么在JavaScript中并没有广泛使用引用计数的原因之一。

分代收集算法

分代收集算法将内存分为新生代和老年代，根据对象的生命周期采用不同的回收策略。新生代对象生命周期较短，频繁进行垃圾回收；老年代对象生命周期较长，较少进行垃圾回收。

class GenerationalGC {
  constructor() {
    this.youngGen = [];
    this.oldGen = [];
  }

  addObject(obj) {
    this.youngGen.push(obj);
  }

  collectYoungGen() {
    const newYoungGen = this.youngGen.filter(obj => !this.isDead(obj));
    this.youngGen = newYoungGen;
  }

  collectOldGen() {
    const newOldGen = this.oldGen.filter(obj => !this.isDead(obj));
    this.oldGen = newOldGen;
  }

  isDead(obj) {
    // 判断对象是否存活
    return false; // 这里简化了判断逻辑
  }

  promoteToOldGen() {
    this.oldGen = this.oldGen.concat(this.youngGen);
    this.youngGen = [];
  }
}

// 示例调用
const gc = new GenerationalGC();
gc.addObject({ name: 'Alice' });
gc.collectYoungGen();
gc.promoteToOldGen();
gc.collectOldGen();

分代收集算法的优点是可以根据对象的生命周期进行高效的内存管理，减少了不必要的垃圾回收操作。缺点是实现起来相对复杂，需要额外的内存开销。

性能对比：差距比我想象的大

在实际项目中，我发现分代收集算法的性能确实比标记-清除和引用计数要好很多。尤其是在处理大量短期对象时，分代收集的优势更加明显。标记-清除虽然简单，但在大数据量下会导致明显的性能下降。引用计数虽然不会导致程序暂停，但在处理循环引用时会遇到问题。

我的选型逻辑

在选择垃圾回收方案时，我会根据具体的项目需求来进行权衡。如果项目中存在大量的短期对象，我会毫不犹豫地选择分代收集算法。如果项目比较简单，数据量不大，那么标记-清除算法也是一个不错的选择。至于引用计数，除非有特殊需求，否则我一般不会考虑。

以上是我的对比总结，有不同看法欢迎评论区交流

这就是我对几种主流垃圾回收方案的一些看法和实际使用经验。希望对你有所帮助，如果有更好的实现方式或者不同的观点，欢迎在评论区留言交流。