JS `WeakRef` 与 `FinalizationRegistry` (ES2021)：更灵活的弱引用管理

各位观众老爷们，大家好！今天咱们来聊聊 JavaScript 里两个有点儿“神秘”，但又非常实用的家伙：WeakRef 和 FinalizationRegistry。它们哥俩是 ES2021 推出的新特性，主要解决的是 JavaScript 中弱引用管理的问题。

引子：JavaScript 的内存管理和垃圾回收

在深入 WeakRef 和 FinalizationRegistry 之前，咱们先简单回顾一下 JavaScript 的内存管理机制。JavaScript 是一种具有自动垃圾回收机制的语言，也就是说，程序员不用手动去 malloc 和 free 内存，语言引擎会自动帮我们处理。

那么问题来了，引擎怎么知道哪些内存是可以回收的呢？答案是：可达性。

简单来说，如果一个对象可以从根对象（比如全局对象）通过一系列引用链访问到，那么它就是“可达的”，引擎就会认为它还在被使用，不会回收它。相反，如果一个对象没有任何引用指向它，或者说它已经“不可达”了，那么引擎就会认为它可以被回收了。

这种机制在大多数情况下都工作得很好，但有时候也会带来一些问题，最常见的就是内存泄漏。

内存泄漏：一场悄无声息的危机

内存泄漏指的是程序中已经不再使用的内存，因为某些原因（比如错误的引用关系）一直无法被垃圾回收器回收，导致可用内存越来越少，最终可能导致程序崩溃。

一个常见的例子就是闭包造成的内存泄漏：

function createLeak() {
  let bigData = new Array(1000000).fill(1); // 占用大量内存的数据
  return function() {
    console.log(bigData.length); // 内部函数引用了 bigData
  };
}

let leakFunction = createLeak();
// leakFunction 还在被引用，所以 createLeak 函数中的 bigData 无法被回收
//即使不调用leakFunction()，bigData依然存在
leakFunction = null; // 现在 bigData 可以被回收了

在这个例子中，leakFunction 引用了 createLeak 函数内部的 bigData 变量，即使我们不再使用 leakFunction，bigData 也不会被回收，除非我们将 leakFunction 设置为 null。

强引用：牢牢抓住，永不放手

JavaScript 默认使用的都是强引用。也就是说，只要有强引用指向一个对象，这个对象就永远不会被垃圾回收器回收。

强引用就像一双牢牢抓住你的手的铁钳，除非你被彻底击败（程序结束），否则它绝不会松手。

弱引用：蜻蜓点水，随风而去

而弱引用则不同，它就像蜻蜓点水，对对象的存在不会产生任何影响。即使一个对象只剩下弱引用指向它，它仍然会被垃圾回收器回收。

弱引用就像一股清风，轻轻拂过，不会留下任何痕迹。

WeakRef：弱引用的化身

WeakRef 就是 JavaScript 中弱引用的化身。它允许我们创建一个指向对象的弱引用，而不会阻止该对象被垃圾回收器回收。

let obj = { name: "张三" };
let weakRef = new WeakRef(obj);

console.log(weakRef.deref()); // 输出: { name: "张三" }

obj = null; // 现在 obj 对象不再有强引用指向它

// 过一段时间后，obj 对象可能会被垃圾回收器回收
setTimeout(() => {
  console.log(weakRef.deref()); // 输出: undefined (如果 obj 被回收了)
}, 1000);

在这个例子中，weakRef 是一个指向 obj 对象的弱引用。当我们将 obj 设置为 null 后，obj 对象不再有强引用指向它，因此它可能会被垃圾回收器回收。如果 obj 被回收了，那么 weakRef.deref() 将会返回 undefined。

WeakRef 的使用场景

WeakRef 主要用于以下几种场景：

缓存: 当缓存中的数据量很大时，可以使用 WeakRef 来缓存那些不经常使用的数据。当内存不足时，垃圾回收器可以回收这些数据，从而释放内存。
观察者模式: 在观察者模式中，如果观察者对象不再需要监听被观察者对象的变化，可以使用 WeakRef 来解除观察关系，防止内存泄漏。
对象关联元数据: 可以用 WeakMap 结合 WeakRef 来实现。WeakMap的键是对象，值是与该对象关联的元数据。如果对象被垃圾回收，那么 WeakMap 中对应的键值对也会被自动删除。

WeakRef 的局限性

WeakRef 也不是万能的，它有一些局限性：

不确定性: 无法确定对象何时会被垃圾回收器回收，因此 weakRef.deref() 可能会返回 undefined。
复活 (Resurrection): 在某些情况下，对象可能会在垃圾回收过程中被“复活”，导致 weakRef.deref() 返回一个有效对象。这通常发生在 FinalizationRegistry 的回调函数中。

FinalizationRegistry：对象的最后一次告别

FinalizationRegistry 允许我们在对象被垃圾回收时执行一些清理工作。它可以看作是对象生命的最后一次告别。

let registry = new FinalizationRegistry(heldValue => {
  console.log("对象被回收了，heldValue:", heldValue);
  // 在这里执行一些清理工作，比如释放资源
});

let obj = { name: "李四" };

registry.register(obj, "obj 的元数据"); // 注册 obj 对象，并传递元数据

obj = null; // 现在 obj 对象不再有强引用指向它

// 过一段时间后，当 obj 对象被垃圾回收时，FinalizationRegistry 的回调函数会被调用

在这个例子中，我们创建了一个 FinalizationRegistry 对象，并使用 register 方法注册了 obj 对象。当 obj 对象被垃圾回收时，FinalizationRegistry 的回调函数会被调用，并传入我们注册时传递的元数据 "obj 的元数据"。

FinalizationRegistry 的使用场景

FinalizationRegistry 主要用于以下几种场景：

释放资源: 当对象持有一些外部资源（比如文件句柄、网络连接）时，可以使用 FinalizationRegistry 来在对象被回收时释放这些资源。
清理缓存: 当缓存中的数据不再需要时，可以使用 FinalizationRegistry 来清理这些数据。
记录日志: 可以使用 FinalizationRegistry 来记录对象被回收的时间，用于调试和性能分析。

FinalizationRegistry 的注意事项

使用 FinalizationRegistry 时需要注意以下几点：

回调函数可能会延迟执行: FinalizationRegistry 的回调函数不是立即执行的，而是会在垃圾回收器认为合适的时候执行。
回调函数可能会在任何时候执行: 无法预测回调函数何时执行，因此不应该在回调函数中执行一些关键的业务逻辑。
避免在回调函数中创建新的强引用: 在回调函数中创建新的强引用可能会导致对象“复活”，从而导致一些意想不到的问题。

WeakRef 和 FinalizationRegistry 的配合使用

WeakRef 和 FinalizationRegistry 通常会一起使用，以实现更灵活的弱引用管理。

例如，我们可以使用 WeakRef 来缓存对象，并使用 FinalizationRegistry 来在对象被回收时清理缓存。

let cache = new Map();
let registry = new FinalizationRegistry(key => {
  console.log(`清理缓存 key: ${key}`);
  cache.delete(key);
});

function getCachedData(key, createData) {
  let weakRef = cache.get(key);
  let data = weakRef ? weakRef.deref() : undefined;

  if (!data) {
    data = createData(key);
    cache.set(key, new WeakRef(data));
    registry.register(data, key); // 注册 data 对象，当data被回收时，从cache中删除对应的key
  }

  return data;
}

let data1 = getCachedData("key1", (key) => { console.log(`创建数据 key: ${key}`); return { value: `data for ${key}` }; });
let data2 = getCachedData("key1", (key) => { console.log(`创建数据 key: ${key}`); return { value: `data for ${key}` }; }); // 从缓存中获取

console.log(data1.value); // 输出: data for key1
console.log(data2.value); // 输出: data for key1

data1 = null;
data2 = null;

// 等待一段时间，让垃圾回收器回收 data1 和 data2 对象
setTimeout(() => {
  console.log("GC 完成后...");
  console.log(cache.size); // 输出: 0 (如果 data1 和 data2 被回收了)
}, 2000);

在这个例子中，我们使用 WeakRef 来缓存数据，并使用 FinalizationRegistry 来在数据被回收时从缓存中删除对应的键值对。这样可以确保缓存中的数据不会占用过多的内存，并且可以避免内存泄漏。

总结：弱引用管理的利器

WeakRef 和 FinalizationRegistry 是 JavaScript 中弱引用管理的利器。它们可以帮助我们更好地管理内存，避免内存泄漏，并提高程序的性能。

特性	WeakRef	FinalizationRegistry
作用	创建对象的弱引用	在对象被垃圾回收时执行清理工作
返回值	WeakRef 对象	FinalizationRegistry 对象
主要方法	`deref()`	`register(object, heldValue)`
使用场景	缓存、观察者模式、对象关联元数据	释放资源、清理缓存、记录日志
注意事项	可能返回 `undefined`、可能发生复活	回调函数可能会延迟执行、可能会在任何时候执行、避免创建强引用

当然，WeakRef 和 FinalizationRegistry 也不是万能的，它们有一些局限性，需要根据具体的场景进行选择和使用。

友情提示：

不要过度依赖 WeakRef 和 FinalizationRegistry，尽量使用更简单的内存管理方式。
在生产环境中使用 WeakRef 和 FinalizationRegistry 之前，一定要进行充分的测试。
时刻关注垃圾回收器的行为，避免出现性能问题。

好了，今天的讲座就到这里，希望大家有所收获！如果还有什么疑问，欢迎在评论区留言，我会尽力解答。下次再见！

发表回复 取消回复

发表回复取消回复