深入探索标记清除法与引用计数法：垃圾回收的双重奏

JavaScript的垃圾回收（Garbage Collection，GC）是自动管理内存的机制，用于检测和释放不再使用的对象，以避免内存泄漏和过度占用内存。两种常见的垃圾回收算法是标记清除法和引用计数法。

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

原理

此算法通过标记对象来跟踪哪些对象仍然在使用中，然后清除未标记的对象。

标记清除法（Mark and Sweep）是一种常用的垃圾回收算法。其基本原理如下：

1. 标记阶段（Marking Phase）：从根对象开始，通过遍历对象引用关系，标记所有活动对象（即可访问到的对象）。垃圾回收器会从全局对象（如window对象）开始，递归遍历对象的属性、字段等，将可访问的对象进行标记。

2. 清除阶段（Sweeping Phase）：在清除阶段，垃圾回收器会扫描堆内存中的所有对象，对于未被标记的对象，即未被标记为活动对象的对象，将其判定为垃圾对象，并进行回收释放内存。

3. 内存整理（Compaction）：清除阶段后可能会产生不连续的内存空间，为了纠正这种内存碎片化的情况，还需要进行内存整理。内存整理的过程是将活动对象按照一定规则移动到一端，从而形成连续的内存块，以便后续的内存分配。

标记清除法通过标记和清除两个阶段来实现垃圾回收。在标记阶段，它通过遍历对象引用关系，确定哪些对象是活动的。在清除阶段，它会将未被标记的对象判定为垃圾，并进行回收释放内存。这种算法能够有效地回收不再使用的对象，但也存在一些缺点，比如可能会产生内存碎片等问题。因此，现代的垃圾回收器通常会采用更复杂的算法来优化性能和内存管理。

过程

1. 垃圾回收器从根对象开始，如全局对象（window）或执行上下文中的变量，将其标记为“活动”。
2. 遍历所有被标记为“活动”的对象，递归地访问其引用的对象，并将它们也标记为“活动”。
3. 最后，垃圾回收器遍历堆中的所有对象，清除未标记的对象，并将它们的内存回收。

优缺点

• 优点：可以处理循环引用（两个或多个对象相互引用）的情况。
• 缺点：垃圾回收的过程会造成一些暂停，可能导致性能问题。

伪代码示例

// 定义一个对象构造函数
function Person(name) {
  this.name = name;
}

// 创建一些对象实例
let person1 = new Person('Alice');
let person2 = new Person('Bob');

// 标记person1为活动对象
mark(person1);

// 引用person1的person2也被标记为活动对象
mark(person2);

// 取消person2的引用，person2变为不可访问的对象
unmark(person2);

// 调用垃圾回收器进行清除未标记对象的操作
sweep();

// 在sweep之后，只有person1被保留，person2被清除
console.log(person1.name); // 输出 'Alice'
console.log(person2.name); // 输出 undefined

// 标记对象为活动状态的函数
function mark(obj) {
  if (obj.isMarked) return; // 避免重复标记

  obj.isMarked = true;

  // 递归标记所有引用的对象
  Object.values(obj).forEach((value) => {
    if (typeof value === 'object' && value !== null) {
      mark(value);
    }
  });
}

// 清除未标记对象的函数
function sweep() {
  Object.keys(window).forEach((key) => {
    const obj = window[key];
    if (typeof obj === 'object' && obj !== null && !obj.isMarked) {
      // 清除未标记的对象
      delete window[key];
    } else {
      // 重置标记状态
      delete obj.isMarked;
    }
  });
}

请注意，这只是一个简化的示例，实际的垃圾回收算法会更加复杂且优化。

在现代的JavaScript引擎中，垃圾回收器会根据对象的生命周期、对象图谱等信息来做出更智能的决策，并且执行垃圾回收的过程不会在代码中呈现出来。

以上示例仅用于演示标记清除法的基本原理，实际的垃圾回收算法实现通常是在底层的引擎中完成的。

🐇🐇2. 引用计数法（Reference Counting）

原理

此算法通过跟踪每个对象的引用次数来判断对象是否不再需要，引用计数为0表示对象可以被回收。

引用计数法（Reference Counting）是一种基本的垃圾回收算法，其原理如下：

每个对象都有一个引用计数，用于记录有多少个引用指向该对象。当一个对象被引用时，其引用计数加1；当一个对象的引用被释放时，其引用计数减1。当引用计数为0时，表示该对象没有被任何引用指向，可以确定该对象不会再被访问，因而可以将其视为垃圾对象，进行回收释放内存。

引用计数法的优点是简单且实时响应，当引用计数为0时即刻回收对象。然而，引用计数法也存在一些缺点：

1. 循环引用问题：如果两个或多个对象相互引用，它们的引用计数永远不会为0，导致存在内存泄漏的风险。

2. 计数更新开销：每次对象引用关系发生变化时，需要更新相关对象的引用计数，增加了运行时的开销。

为了解决循环引用问题，通常需要使用其他垃圾回收算法，如标记清除法、标记-压缩法等，来检测并回收循环引用的对象。引用计数法通常作为其他垃圾回收算法的辅助手段，在一些特定的场景下仍然有一定的应用价值。

过程

1. 在创建对象时，将引用计数初始化为1。
2. 当对象被引用时，引用计数加1；当引用被释放时，引用计数减1。
3. 垃圾回收器定期检查对象的引用计数，当引用计数为0时，回收对象的内存。

优缺点

• 优点：垃圾回收的过程分散在对象被引用和释放的操作中，可以避免全局的垃圾回收暂停。
• 缺点：无法处理循环引用的情况，导致内存泄漏。例如，如果两个对象相互引用，即使它们不再被使用，它们的引用计数也不会为0。

伪代码示例

// 定义一个对象构造函数
function Person(name) {
  this.name = name;
  this.refCount = 0; // 引用计数初始化为0
}

// 创建一些对象实例
let person1 = new Person('Alice');
let person2 = new Person('Bob');

// 增加引用计数
increaseRefCount(person1);
increaseRefCount(person2);

// 减少引用计数
decreaseRefCount(person2);

// 调用垃圾回收器进行清除没有引用的对象的操作
garbageCollect();

// 在垃圾回收后，只有person1被保留，person2被清除
console.log(person1.name); // 输出 'Alice'
console.log(person2.name); // 输出 undefined

// 增加引用计数的函数
function increaseRefCount(obj) {
  obj.refCount++;
}

// 减少引用计数的函数
function decreaseRefCount(obj) {
  obj.refCount--;
  if (obj.refCount === 0) {
    // 当引用计数为0时，对象变为垃圾，可以清除
    garbageCollect(obj);
  }
}

// 清除没有引用的对象的函数
function garbageCollect() {
  Object.keys(window).forEach((key) => {
    const obj = window[key];
    if (obj && obj.refCount === 0) {
      delete window[key];
    }
  });
}

需要注意的是，引用计数法的一个主要问题是无法解决循环引用的情况，即使两个对象相互引用，它们的引用计数也不会变为0。

因此，在实际的垃圾回收算法中，通常会采用其他技术来解决循环引用问题，比如使用标记清除法等。以上示例仅用于演示引用计数法的基本原理，实际的垃圾回收算法实现通常是在底层的引擎中完成的。

现代的JavaScript引擎（如V8、SpiderMonkey）通常使用更高级的垃圾回收算法，结合标记清除法和引用计数法，并进行优化。例如，使用分代回收策略，将对象按生命周期分为不同的代，根据对象的存活时间采取不同的垃圾回收策略。

总的来说，标记清除法适用于大部分情况下，能够处理循环引用，但可能造成性能问题；引用计数法简单但无法处理循环引用，容易导致内存泄漏。因此，现代的JavaScript引擎会综合考虑不同算法的优势，并进行优化和改进，以提供更高效的垃圾回收机制。