WeakMap/WeakSet 的垃圾回收原理：弱引用与可达性（Reachability）算法

弱引用与可达性：揭秘 WeakMap/WeakSet 的垃圾回收原理

各位技术同仁，大家好。今天我们将深入探讨 JavaScript 中两个特殊的数据结构：WeakMap 和 WeakSet。它们在内存管理方面扮演着至关重要的角色，尤其是在处理“弱引用”和“可达性”概念时，能够帮助我们构建更加健壮、内存效率更高的应用程序。理解它们的工作原理，特别是与垃圾回收（Garbage Collection, GC）机制的交互，是成为一名优秀 JavaScript 工程师的必经之路。

1. 内存管理的挑战与垃圾回收的诞生

在计算机编程中，内存管理一直是核心且复杂的任务。早期的编程语言，如 C 和 C++，要求开发者手动分配和释放内存。这种手动管理赋予了开发者极大的控制权，但也带来了臭名昭著的内存泄漏（memory leak）和悬垂指针（dangling pointer）等问题，极大地增加了程序出错的概率和调试的难度。

为了解决这些问题，自动化内存管理机制——垃圾回收（Garbage Collection, GC）应运而生。GC 的核心思想是自动识别并回收程序中不再使用的内存。在 JavaScript 这样的高级语言中，我们几乎感觉不到 GC 的存在，但它始终在幕后默默工作，确保我们不必为内存的分配和释放而烦恼。

主流的垃圾回收算法有很多种，例如引用计数（Reference Counting）和标记-清除（Mark-and-Sweep）等。虽然 JavaScript 引擎的具体实现可能有所不同，但大多数现代引擎都采用或基于标记-清除算法及其变种，因为它能有效解决循环引用导致的内存泄漏问题。而标记-清除算法的核心，正是我们今天要重点探讨的“可达性”（Reachability）概念。

2. 强引用：可达性的基石

在深入弱引用之前，我们必须透彻理解“强引用”和“可达性”。在 JavaScript 中，当我们创建一个对象并将其赋值给一个变量时，我们就创建了一个强引用。

let obj1 = { name: "Object 1" }; // obj1 强引用了 { name: "Object 1" }
let obj2 = obj1;                 // obj2 也强引用了同一个对象

一个对象是否“存活”在内存中，取决于它是否“可达”。可达性是一个从“根”（Roots）开始的概念。在 JavaScript 运行时环境中，根通常包括：

• 全局对象：例如浏览器环境中的 window 或 Node.js 环境中的 globalThis。
• 当前执行栈上的变量：包括函数参数、局部变量等。
• 其他由宿主环境（如浏览器或 Node.js）持有的对象。

垃圾回收器从这些根开始，遍历所有通过强引用可以直接或间接访问到的对象。所有能够被访问到的对象都被认为是“可达的”，因此是“存活的”，不应该被回收。反之，如果一个对象从根开始，没有任何强引用链能够到达它，那么它就是“不可达的”，也就是“垃圾”，可以被垃圾回收器清除。

我们来看一个简单的例子：

let user = {
    name: "Alice",
    age: 30
};

let admin = user; // admin 强引用了 user 指向的对象

user = null; // user 变量不再引用该对象

// 此时，虽然 user 变量不再指向该对象，但 admin 变量仍然强引用着它。
// 因此，该对象仍然是可达的，不会被垃圾回收。

admin = null; // admin 变量也不再引用该对象

// 现在，从任何根开始，都没有强引用指向 { name: "Alice", age: 30 } 这个对象了。
// 该对象变得不可达，会在下一次垃圾回收循环中被清除。

这个机制非常直观且强大，它解决了手动内存管理带来的许多问题。然而，在某些特定的场景下，强引用也会带来一些意想不到的内存管理挑战。

3. 强引用带来的挑战：元数据与内存泄漏

设想这样一个场景：我们有一个应用程序，其中包含许多用户对象。我们希望为这些用户对象存储一些“辅助数据”或“元数据”，例如，某个用户最近一次登录的时间，或者该用户是否在线的临时状态。这些元数据与用户对象本身紧密相关，但我们不希望这些元数据影响用户对象的生命周期。换句话说，当用户对象不再被程序其他部分使用时，我们希望它能够被垃圾回收，并且它所关联的元数据也应该随之消失，而不需要我们手动去清理。

如果使用普通的 Map 来存储这种关联关系，会发生什么呢？

const userDataMap = new Map();

let user1 = { id: 1, name: "Alice" };
let user2 = { id: 2, name: "Bob" };

userDataMap.set(user1, { lastLogin: new Date(), status: "online" });
userDataMap.set(user2, { lastLogin: new Date(), status: "offline" });

console.log(userDataMap.get(user1));
// { lastLogin: ..., status: 'online' }

// 假设 user1 对象在应用程序的其他地方不再需要了
user1 = null;

// 问题来了：
// 尽管 user1 变量现在是 null，但 { id: 1, name: "Alice" } 这个对象仍然是 userDataMap 的一个键。
// Map 内部对它的键是持有强引用的。
// 这意味着，即使没有其他变量引用 user1，它也不会被垃圾回收，因为它被 userDataMap 强引用着。
// 结果就是，与 user1 关联的元数据，以及 user1 本身，会一直占据内存，直到 userDataMap 被清空或被垃圾回收。

// 如果不手动删除，就会导致内存泄漏：
// userDataMap.delete(user1); // 必须手动执行，否则 user1 对象及其元数据不会被 GC

这个例子清晰地展示了传统 Map 在这种场景下的局限性。Map 会强引用它的所有键，这意味着即使一个对象在应用程序的逻辑上已经“死亡”，但只要它还是 Map 的一个键，它就会一直存活在内存中，从而阻止其被垃圾回收。这不仅可能导致内存泄漏，还会使得与该对象关联的数据也无法被回收。

为了解决这个问题，JavaScript 引入了 WeakMap 和 WeakSet。

4. 弱引用：WeakMap 的核心原理

WeakMap 是一种特殊的 Map，它的键是“弱引用”的。理解“弱引用”是理解 WeakMap 工作的关键。

弱引用的定义：

一个弱引用不会阻止垃圾回收器回收它所指向的对象。换句话说，如果一个对象只被弱引用所引用，那么它就是可被垃圾回收的。当垃圾回收器检测到某个对象不再通过强引用链从根可达时，即使该对象是 WeakMap 的一个键，它也会被回收。一旦键对象被回收，WeakMap 中对应的键值对就会自动从 WeakMap 中移除。

这正是 WeakMap 的神奇之处：它允许我们关联数据到一个对象，而无需担心这种关联会阻止对象被垃圾回收。

WeakMap 的基本特性

1. 键必须是对象：WeakMap 的键只能是对象（包括函数、数组等，以及包装类型如 new Number(1)，但不能是原始值，如 string, number, boolean, symbol, null, undefined）。这是因为垃圾回收器追踪的是对象的内存地址和可达性，原始值没有“身份”，它们是按值比较的，无法作为弱引用的目标。
2. 键是弱引用：这是 WeakMap 的核心特性。
3. 不可枚举：WeakMap 没有 keys(), values(), entries() 等方法，也没有 size 属性，不能进行迭代。这是因为 WeakMap 的键随时可能被垃圾回收，导致 WeakMap 的内容发生变化。如果允许迭代，那么迭代的结果将是不确定的，甚至可能在迭代过程中键就被回收了，这会引入难以预测的行为。
4. 非确定性清理：键值对的清理时机由垃圾回收器决定，是非确定性的。我们无法预测一个键何时会被回收，也无法手动触发清理。

WeakMap 与 Map 的对比

特性	Map	WeakMap
键的类型	任何值（原始值或对象）	只能是对象
键的引用强度	强引用（阻止键被垃圾回收）	弱引用（不阻止键被垃圾回收）
值的引用强度	强引用	强引用（只要键未被回收）
可迭代性	可迭代（keys(), values(), entries(), forEach(), size）	不可迭代（没有上述方法和属性）
内存清理	需手动 delete() 清理，否则可能内存泄漏	自动清理，当键不再可达时由 GC 自动移除对应条目
主要用途	通用键值对存储	关联元数据到对象，不影响对象生命周期

WeakMap 的使用

WeakMap 的 API 与 Map 非常相似，但功能受限。

const myWeakMap = new WeakMap();

let obj1 = { id: 1 };
let obj2 = { id: 2 };

// set(key, value): 添加键值对
myWeakMap.set(obj1, "这是 obj1 的秘密数据");
myWeakMap.set(obj2, { someData: "复杂对象的数据" });

console.log(myWeakMap.get(obj1)); // "这是 obj1 的秘密数据"
console.log(myWeakMap.has(obj2)); // true

// get(key): 获取值
const dataForObj2 = myWeakMap.get(obj2);
console.log(dataForObj2); // { someData: '复杂对象的数据' }

// delete(key): 删除键值对
myWeakMap.delete(obj1);
console.log(myWeakMap.has(obj1)); // false (手动删除)

// 演示 GC 行为（模拟）
let user = { id: 3, name: "Charlie" };
myWeakMap.set(user, "Charlie 的用户数据");

console.log("在 user 失去引用前:", myWeakMap.has(user)); // true

// 将 user 变量置为 null，解除强引用
user = null;

// 此时，{ id: 3, name: "Charlie" } 这个对象已经没有任何强引用指向它了。
// 它现在只被 myWeakMap 弱引用着。
// 在下一次垃圾回收循环中，该对象会被回收，同时 myWeakMap 中对应的条目也会被自动移除。

// 由于 GC 的非确定性，我们无法立即观察到 has(user) 变为 false
// 但在某个未来的时刻，它会变成 false。
// 为了模拟，我们可以等待一段时间，但并不能保证 GC 立即运行。
setTimeout(() => {
    // 理论上，经过一段时间和 GC 运行后，这个键值对应该被清理
    // 实际运行中，取决于 JS 引擎和 GC 策略，可能需要更长时间或多次 GC 循环
    console.log("在 user 失去引用后（等待 GC 发生）:", myWeakMap.has(user));
    // 预期结果：false (如果 GC 足够快且已经清理了)
}, 1000);

请注意，WeakMap 中的 值 仍然是强引用的。这意味着，如果一个对象 value 仅作为 WeakMap 中某个键 key 的值而存在，那么只要 key 仍然可达（未被 GC），value 也会保持可达。一旦 key 被 GC 回收，value 也就失去了它唯一的强引用来源（如果 WeakMap 是唯一引用它的地方），从而 value 也变得可回收。

let keyObj = { id: 1 };
let valueObj = { data: "associated data" };

const wm = new WeakMap();
wm.set(keyObj, valueObj);

// 此时，keyObj 和 valueObj 都被 wm 强引用着（valueObj 被 keyObj 通过 wm 强引用）
// 准确地说，valueObj 被 wm 强引用着，只要 keyObj 仍是 wm 的键。

// 解除 keyObj 的强引用
keyObj = null;

// 现在，keyObj 指向的对象变得不可达（除了 wm 中的弱引用）。
// 在 GC 运行后，keyObj 指向的对象会被回收。
// 随之，wm 中对应的条目会被移除。
// 如果 valueObj 没有其他强引用，它也会变得不可达，并被 GC 回收。

// 模拟 GC 后的状态
setTimeout(() => {
    // 理论上，valueObj 应该已经被回收了，如果没有其他强引用。
    // 我们无法直接检查 valueObj 是否被回收，但可以理解其生命周期已结束。
    console.log("keyObj 和 valueObj 应该已被 GC (如果无其他引用)");
}, 1000);

5. WeakSet：弱引用的集合

与 WeakMap 类似，WeakSet 也是一个集合，但它存储的是对象的弱引用。

WeakSet 的基本特性

1. 元素必须是对象：与 WeakMap 类似，WeakSet 的元素也只能是对象。
2. 元素是弱引用：WeakSet 的核心特性。当一个对象在外部不再有强引用时，即使它是 WeakSet 的一个元素，也会被垃圾回收。一旦对象被回收，它就会自动从 WeakSet 中移除。
3. 不可枚举：WeakSet 没有 keys(), values(), entries(), forEach() 等方法，也没有 size 属性，不能进行迭代。原因与 WeakMap 相同。
4. 非确定性清理：元素的清理时机由垃圾回收器决定，是非确定性的。

WeakSet 与 Set 的对比

特性	Set	WeakSet
元素类型	任何值（原始值或对象）	只能是对象
元素引用强度	强引用（阻止元素被垃圾回收）	弱引用（不阻止元素被垃圾回收）
可迭代性	可迭代（keys(), values(), entries(), forEach(), size）	不可迭代（没有上述方法和属性）
内存清理	需手动 delete() 清理，否则可能内存泄漏	自动清理，当元素不再可达时由 GC 自动移除
主要用途	存储唯一值的集合	跟踪一组对象，不影响对象生命周期

WeakSet 的使用

WeakSet 的 API 也与 Set 类似，但功能受限。

const processedObjects = new WeakSet();

let item1 = { name: "Report A" };
let item2 = { name: "Report B" };
let item3 = { name: "Report C" };

// add(value): 添加元素
processedObjects.add(item1);
processedObjects.add(item2);

console.log(processedObjects.has(item1)); // true
console.log(processedObjects.has(item3)); // false

// delete(value): 删除元素
processedObjects.delete(item1);
console.log(processedObjects.has(item1)); // false

// 演示 GC 行为（模拟）
processedObjects.add(item3);
console.log("在 item2 失去引用前:", processedObjects.has(item2)); // true
console.log("在 item3 失去引用前:", processedObjects.has(item3)); // true

// 解除 item2 的强引用
item2 = null;

// item3 仍然被强引用着
// let temp = item3; // 假设这里有一个强引用

// 此时，{ name: "Report B" } 对象不再从根强可达，只被 processedObjects 弱引用。
// 在 GC 运行后，它将被回收，并从 processedObjects 中自动移除。

// { name: "Report C" } 对象仍然被 item3 变量强引用着，所以它不会被回收。
// 相应的，它会保留在 processedObjects 中。

setTimeout(() => {
    // 理论上，经过一段时间和 GC 运行后
    console.log("在 item2 失去引用后（等待 GC 发生）:", processedObjects.has(item2));
    // 预期结果：false
    console.log("在 item3 失去引用后（等待 GC 发生）:", processedObjects.has(item3));
    // 预期结果：true (因为 item3 仍然有强引用)
}, 1000);

WeakSet 常用于标记或跟踪一组对象，例如，记录哪些 DOM 元素已经注册了事件监听器，或者哪些对象已经经过了某个处理流程，而不需要这些标记阻止对象自身的垃圾回收。

6. 垃圾回收器与弱引用的交互机制

为了更深入地理解 WeakMap/WeakSet，我们需要简要回顾垃圾回收器是如何处理可达性的。

现代 JavaScript 引擎通常采用一种变种的标记-清除算法。这个过程可以概括为以下几个阶段：

1. 标记阶段 (Marking Phase)：

   • 垃圾回收器会从一组已知的“根”（如全局对象、当前调用栈上的变量等）开始。
   • 它会遍历所有从根出发，通过强引用可以直接或间接访问到的对象。
   • 所有这些可访问到的对象都会被打上“可达”或“存活”的标记。
   • 关键点：在这个阶段，垃圾回收器会忽略弱引用。这意味着，一个对象即使被 WeakMap 或 WeakSet 引用了，如果它没有其他强引用使其从根可达，它也不会在标记阶段被标记为“存活”。

2. 清除阶段 (Sweeping Phase)：

   • 在标记阶段完成后，垃圾回收器会遍历整个堆内存。
   • 所有没有被标记为“存活”的对象，都会被认为是“垃圾”，其占据的内存空间将被回收。

WeakMap/WeakSet 如何融入这个流程？

当垃圾回收器在标记阶段结束后，发现某个对象 obj 并没有被任何强引用链从根标记为“存活”，但它却是某个 WeakMap 的键或 WeakSet 的元素时：

• 垃圾回收器会认为 obj 是不可达的，可以被回收。
• 在 obj 真正被回收之前（或者在回收的同时），WeakMap 或 WeakSet 会被通知，并自动移除所有以 obj 为键或以 obj 为元素的条目。
• 这样，当 obj 的内存被释放时，WeakMap/WeakSet 中也不会留下对已回收对象的“悬垂”引用。

这个过程确保了 WeakMap/WeakSet 的弱引用特性得以实现，并且它们的内部状态始终与实际存活的对象保持一致。值得注意的是，这个清理过程是非确定性的。我们无法精确地知道垃圾回收器何时会运行，也无法预测 WeakMap/WeakSet 中的条目何时会被清理。它通常在后台异步执行，以避免阻塞主线程。

7. 实际应用场景与最佳实践

理解了 WeakMap 和 WeakSet 的原理，我们来看看它们在实际开发中能解决哪些问题。

WeakMap 的常见用途：

1. 为 DOM 元素附加私有数据或元数据：
   在 Web 开发中，我们经常需要为 DOM 元素存储一些额外的数据，例如，一个元素是否已经被初始化，或者与某个组件实例的关联。如果直接在 DOM 元素上添加属性，可能会污染全局命名空间。使用 Map 会阻止 DOM 元素被回收。WeakMap 完美解决了这个问题。

   const elementData = new WeakMap();
   
   function initializeElement(element) {
       if (!elementData.has(element)) {
           const data = {
               initializedAt: new Date(),
               componentInstance: new MyComponent(element)
           };
           elementData.set(element, data);
           console.log("Element initialized:", element);
       } else {
           console.log("Element already initialized:", elementData.get(element));
       }
   }
   
   let myDiv = document.createElement('div');
   document.body.appendChild(myDiv);
   
   initializeElement(myDiv);
   // ... 对 myDiv 进行操作
   
   // 当 myDiv 从 DOM 中移除，并且不再被任何 JavaScript 变量强引用时
   // 比如：document.body.removeChild(myDiv);
   // myDiv = null;
   // 此时，myDiv 对象最终会被 GC 回收，同时 elementData 中对应的条目也会自动清理。

2. 缓存计算结果：
   当一个函数的计算结果依赖于一个对象，并且这个计算比较耗时时，我们可以使用 WeakMap 来缓存结果。这样，只要输入对象还存在，我们就可以快速获取缓存结果；当输入对象被回收时，对应的缓存也会自动清理，避免内存泄漏。

   const cache = new WeakMap();
   
   function expensiveCalculation(obj) {
       if (cache.has(obj)) {
           console.log("从缓存获取:", obj);
           return cache.get(obj);
       }
   
       console.log("执行耗时计算:", obj);
       // 模拟耗时计算
       let result = Math.random() * 10000;
       cache.set(obj, result);
       return result;
   }
   
   let data1 = { value: 10 };
   let data2 = { value: 20 };
   
   console.log(expensiveCalculation(data1)); // 执行计算
   console.log(expensiveCalculation(data1)); // 从缓存获取
   console.log(expensiveCalculation(data2)); // 执行计算
   
   data1 = null; // data1 对象现在可以被 GC 回收了
   // 当 data1 被回收时，cache 中对应的条目也会被移除。

3. 实现类的私有成员（在 ES2015+ 类私有字段出现之前的一种模式）：
   虽然现在有了 #privateField 语法，但在某些不支持或需要更灵活控制的场景下，WeakMap 仍然可以作为一种实现私有数据的机制。

   const privateData = new WeakMap();
   
   class MyClass {
       constructor(initialValue) {
           privateData.set(this, {
               _secret: initialValue,
               _counter: 0
           });
       }
   
       increment() {
           const data = privateData.get(this);
           data._counter++;
           console.log(`Counter: ${data._counter}, Secret: ${data._secret}`);
       }
   
       getSecret() {
           return privateData.get(this)._secret;
       }
   }
   
   let instance1 = new MyClass("super secret");
   instance1.increment(); // Counter: 1, Secret: super secret
   console.log(instance1.getSecret()); // super secret
   
   // 外部无法直接访问 _secret 或 _counter
   
   // 当 instance1 被回收时，privateData 中对应的条目也会自动清理。
   instance1 = null;

WeakSet 的常见用途：

1. 跟踪已处理对象：
   在处理一组对象时，我们可能需要记录哪些对象已经经过了某个处理流程，以避免重复处理。WeakSet 可以很好地实现这一点，而不会阻止这些对象在不再需要时被回收。

   const processedItems = new WeakSet();
   
   function processItem(item) {
       if (processedItems.has(item)) {
           console.log("Item already processed:", item);
           return;
       }
   
       console.log("Processing item:", item);
       // 执行实际处理逻辑
       processedItems.add(item);
   }
   
   let productA = { id: 'A', price: 100 };
   let productB = { id: 'B', price: 200 };
   
   processItem(productA); // Processing item: { id: 'A', price: 100 }
   processItem(productA); // Item already processed: { id: 'A', price: 100 }
   processItem(productB); // Processing item: { id: 'B', price: 200 }
   
   productA = null; // 当 productA 不再被其他地方引用时，它将被 GC 回收
   // 随之，processedItems 中对应的条目也会被移除。

2. 管理一组活动对象：
   例如，一个游戏引擎可能需要跟踪所有当前处于活动状态的游戏实体。当实体被销毁或离开游戏区域时，如果它不再被其他强引用，它应该被回收。WeakSet 可以在不阻止回收的前提下，提供一个快速检查实体是否仍在活动集合中的机制。

何时不使用 WeakMap/WeakSet：

• 你需要迭代键/元素：如果你的逻辑需要遍历所有键或元素，或者需要知道集合的大小，WeakMap/WeakSet 是不合适的，因为它们不支持这些操作。
• 你需要存储原始值：WeakMap/WeakSet 的键/元素必须是对象。
• 你希望引用阻止对象被垃圾回收：如果你希望你的引用能够确保对象存活，那么应该使用 Map 或 Set，或者普通的变量引用。
• 你需要确定性的清理时机：由于垃圾回收是非确定性的，WeakMap/WeakSet 的清理也是非确定性的。如果你需要精确控制对象何时被清理，你可能需要结合其他模式，或者使用像 FinalizationRegistry 这样的更底层 API（但需谨慎使用）。

8. FinalizationRegistry 和 WeakRef 的补充说明

ES2021 引入了 WeakRef 和 FinalizationRegistry，它们提供了更直接、更底层的弱引用和终结器（finalizer）机制。

• WeakRef：允许你创建一个对象的弱引用。你可以通过 weakRef.deref() 方法尝试获取原始对象。如果原始对象已经被垃圾回收，deref() 将返回 undefined。这与 WeakMap 的键弱引用不同，WeakMap 内部管理弱引用，你不能直接获取到弱引用本身。
• FinalizationRegistry：允许你注册一个回调函数，当一个对象被垃圾回收时，这个回调函数会被调用。这提供了一种在对象被清理后执行清理操作的机制，例如关闭文件句柄、释放非内存资源等。

这些新特性赋予了开发者更精细的内存管理能力，但它们也带来了更高的复杂性和潜在的陷阱（例如，终结器中的内存泄漏、WeakRef 带来的“复活”问题）。对于大多数场景，WeakMap 和 WeakSet 仍然是关联数据而不影响对象生命周期的首选工具，因为它们封装了弱引用的复杂性，提供了更安全、更易用的 API。

总结思考

WeakMap 和 WeakSet 是 JavaScript 中强大而精妙的内存管理工具。它们的核心在于利用弱引用，使得我们能够将辅助数据或状态与对象关联起来，而无需担心这种关联会阻止对象被垃圾回收。这对于解决内存泄漏、实现私有数据、构建高效缓存以及跟踪对象生命周期等方面都至关重要。

深入理解弱引用与垃圾回收器的可达性算法之间的交互，是有效利用 WeakMap 和 WeakSet 的关键。它们的设计哲学是“不干预对象的生命周期”，这使得它们在需要轻量级、自动清理的关联数据场景中表现出色。但同时，由于其弱引用和非可迭代的特性，它们并不适用于所有键值对或集合管理的场景。选择正确的工具，永远是编程艺术的核心。掌握 WeakMap 和 WeakSet，无疑会提升你在构建高性能、高内存效率 JavaScript 应用方面的能力。