JS `WeakRef` 与 `FinalizationRegistry` 结合实现自动资源清理

咳咳，麦克风试音，一二三… 大家好！今天咱们来聊聊 JavaScript 里两个有点“神出鬼没”的家伙：WeakRef 和 FinalizationRegistry，以及它们如何联手实现自动资源清理。准备好了吗？咱们开始！

开场白：JavaScript 的“内存清洁工”

在传统的编程语言里，比如 C++，资源管理是个老大难问题，程序员得自己手动分配和释放内存，一不小心就会出现内存泄漏，痛苦不堪。JavaScript 有垃圾回收机制（Garbage Collection，GC），大部分时候我们不需要操心内存问题。但是，有些场景下，GC 也会力不从心，尤其是在处理一些需要显式释放的资源，比如文件句柄、网络连接、或者一些外部库的资源。

这时候，WeakRef 和 FinalizationRegistry 就闪亮登场了，它们就像 JavaScript 的“内存清洁工”，帮助我们优雅地处理这些资源，避免内存泄漏，让代码更健壮。

第一部分：WeakRef —— “弱弱”的引用

首先，咱们来认识一下 WeakRef。你可以把它想象成一个“弱弱”的引用。什么意思呢？普通的引用，比如 let obj = { name: 'Tom' };，会阻止垃圾回收器回收 obj 指向的对象。也就是说，只要 obj 存在，{ name: 'Tom' } 就不会被回收。

但是，WeakRef 就不一样了。它不会阻止垃圾回收器回收对象。如果一个对象只被 WeakRef 引用，那么当垃圾回收器认为需要回收这个对象时，它就会被回收，即使 WeakRef 还存在。

WeakRef 的基本用法

let obj = { name: 'Tom' };
let weakRef = new WeakRef(obj);

console.log(weakRef.deref()); // 输出: { name: 'Tom' }

obj = null; // 解除强引用

// 稍等片刻，让垃圾回收器有机会运行
// (这里只是模拟，实际情况不可预测)
setTimeout(() => {
  console.log(weakRef.deref()); // 输出: undefined (如果对象已被回收) 或者 { name: 'Tom' } (如果对象还没被回收)
}, 1000);

代码解释：

我们创建了一个对象 obj，并用 WeakRef 创建了一个弱引用 weakRef。
weakRef.deref() 方法可以用来获取 WeakRef 引用的对象。如果对象还存在，就返回对象；如果对象已经被回收，就返回 undefined。
我们把 obj 设置为 null，解除了强引用。这时候，如果垃圾回收器运行，并且认为 obj 指向的对象可以被回收，那么它就会被回收。
setTimeout 只是为了给垃圾回收器一个运行的机会。实际上，我们无法预测垃圾回收器何时运行。

WeakRef 的应用场景

缓存： 可以用 WeakRef 来缓存一些计算结果，如果内存紧张，这些缓存可以被回收。
观察者模式： 可以用 WeakRef 来存储观察者，当观察者被销毁时，自动从观察者列表中移除。

第二部分：FinalizationRegistry —— “临终遗言”

接下来，我们来认识一下 FinalizationRegistry。你可以把它想象成一个“临终遗言”的登记处。当一个对象被垃圾回收器回收时，FinalizationRegistry 可以让我们知道这个事件，并执行一些清理工作。

FinalizationRegistry 的基本用法

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

let obj = { name: 'Tom' };
registry.register(obj, 'Tom的对象');

obj = null; // 解除强引用

// 稍等片刻，让垃圾回收器有机会运行
// (这里只是模拟，实际情况不可预测)
setTimeout(() => {
  console.log('等待垃圾回收...');
}, 5000); //等待5秒，方便看打印信息

代码解释：

我们创建了一个 FinalizationRegistry 对象，并传入一个回调函数。这个回调函数会在对象被回收时执行。回调函数接收一个参数 heldValue，这个参数是在注册对象时传入的。
我们使用 registry.register(obj, 'Tom的对象') 方法注册了对象 obj。第一个参数是要监听的对象，第二个参数是 heldValue，会在回调函数中接收到。
我们把 obj 设置为 null，解除了强引用。
当垃圾回收器回收 obj 指向的对象时，FinalizationRegistry 的回调函数就会被执行，并打印出 "对象被回收了，heldValue: Tom的对象"。

FinalizationRegistry 的应用场景

资源清理： 当对象被回收时，释放相关的资源，比如文件句柄、网络连接等。
日志记录： 记录对象被回收的时间和原因，用于调试和性能分析。

第三部分：WeakRef + FinalizationRegistry —— “黄金搭档”

现在，我们把 WeakRef 和 FinalizationRegistry 结合起来，看看它们如何协同工作，实现自动资源清理。

示例：自动关闭文件句柄

假设我们有一个 FileManager 类，用于管理文件句柄。我们希望当 FileManager 对象被回收时，自动关闭文件句柄。

class FileManager {
  constructor(filename) {
    this.filename = filename;
    this.fileHandle = this.openFile(filename); // 模拟打开文件
    console.log(`文件 ${filename} 打开`);
  }

  openFile(filename) {
    // 模拟打开文件，返回一个文件句柄
    return {
      filename: filename,
      isClosed: false,
      close: () => {
        if (!this.fileHandle.isClosed) {
          console.log(`文件 ${filename} 关闭`);
          this.fileHandle.isClosed = true;
        } else {
          console.log(`文件 ${filename} 已经关闭`);
        }

      },
    };
  }

  close() {
    this.fileHandle.close();
  }

  readFile() {
    if (!this.fileHandle.isClosed) {
      console.log(`读取文件 ${this.filename}`);
      return `文件 ${this.filename} 的内容`; // 模拟读取文件
    } else {
      console.log(`文件 ${this.filename} 已经关闭，无法读取`);
      return null;
    }
  }
}

const registry = new FinalizationRegistry(heldValue => {
  console.log(`FileManager 对象被回收，关闭文件 ${heldValue.filename}`);
  heldValue.close(); // 关闭文件句柄
});

let fileManager = new FileManager('test.txt');
registry.register(fileManager, fileManager.fileHandle);

fileManager = null; // 解除强引用

// 稍等片刻，让垃圾回收器有机会运行
// (这里只是模拟，实际情况不可预测)
setTimeout(() => {
  console.log('等待垃圾回收...');
}, 5000);

代码解释：

FileManager 类负责打开、读取和关闭文件。
我们创建了一个 FinalizationRegistry 对象，当对象被回收时，会调用回调函数，关闭文件句柄。
我们使用 registry.register(fileManager, fileManager.fileHandle) 方法注册了 fileManager 对象，并将文件句柄作为 heldValue 传入。
当 fileManager 对象被回收时，FinalizationRegistry 的回调函数会被执行，并关闭文件句柄。

更进一步：使用 WeakRef 优化

上面的代码有一个问题：FinalizationRegistry 持有对 fileManager 对象的强引用，即使 fileManager 不再被其他地方引用，它也不会被垃圾回收器回收。这违背了我们使用 FinalizationRegistry 的初衷。

为了解决这个问题，我们可以使用 WeakRef 来引用 fileManager 对象。

class FileManager {
    constructor(filename) {
      this.filename = filename;
      this.fileHandle = this.openFile(filename); // 模拟打开文件
      console.log(`文件 ${filename} 打开`);
    }

    openFile(filename) {
      // 模拟打开文件，返回一个文件句柄
      return {
        filename: filename,
        isClosed: false,
        close: () => {
          if (!this.fileHandle.isClosed) {
            console.log(`文件 ${filename} 关闭`);
            this.fileHandle.isClosed = true;
          } else {
            console.log(`文件 ${filename} 已经关闭`);
          }

        },
      };
    }

    close() {
      this.fileHandle.close();
    }

    readFile() {
      if (!this.fileHandle.isClosed) {
        console.log(`读取文件 ${this.filename}`);
        return `文件 ${this.filename} 的内容`; // 模拟读取文件
      } else {
        console.log(`文件 ${this.filename} 已经关闭，无法读取`);
        return null;
      }
    }
  }

  const registry = new FinalizationRegistry(heldValue => {
    const fileManagerRef = heldValue.fileManagerRef;
    const fileHandle = heldValue.fileHandle;

    // 注意，这里需要检查 WeakRef 是否还指向对象
    const fileManager = fileManagerRef.deref();
    if (fileManager) {
      console.log(`FileManager 对象被回收，关闭文件 ${fileHandle.filename}`);
      fileHandle.close(); // 关闭文件句柄
    } else {
      console.log("FileManager 已经被回收，无需关闭文件");
    }

  });

  let fileManager = new FileManager('test.txt');
  const fileManagerRef = new WeakRef(fileManager); // 创建 WeakRef
  registry.register(fileManager, { fileManagerRef: fileManagerRef, fileHandle: fileManager.fileHandle });  // 传入 WeakRef 和 fileHandle

  fileManager = null; // 解除强引用

  // 稍等片刻，让垃圾回收器有机会运行
  // (这里只是模拟，实际情况不可预测)
  setTimeout(() => {
    console.log('等待垃圾回收...');
  }, 5000);

代码解释：

我们创建了一个 WeakRef 对象 fileManagerRef，指向 fileManager 对象。
我们将 fileManagerRef 和 fileManager.fileHandle 作为 heldValue 传入 registry.register() 方法。
在 FinalizationRegistry 的回调函数中，我们首先使用 fileManagerRef.deref() 方法获取 fileManager 对象。如果对象还存在，我们就关闭文件句柄。

总结：WeakRef + FinalizationRegistry 的优势

自动资源清理： 当对象被回收时，自动释放相关的资源，避免内存泄漏。
非侵入性： 不需要修改对象的代码，就可以实现资源清理。
解耦： 对象和资源清理逻辑分离，代码更清晰。

注意事项

垃圾回收器行为不可预测： 垃圾回收器何时运行，我们无法预测。因此，不能依赖 FinalizationRegistry 来执行关键的清理工作。
避免循环引用： 避免 FinalizationRegistry 的回调函数中创建对对象的强引用，否则会导致内存泄漏。
性能影响： WeakRef 和 FinalizationRegistry 会增加垃圾回收器的负担，可能影响性能。

表格：WeakRef vs. 普通引用

特性	`WeakRef`	普通引用
回收影响	不阻止垃圾回收器回收对象	阻止垃圾回收器回收对象
获取对象	需要使用 `deref()` 方法	直接访问对象
应用场景	缓存、观察者模式、资源清理等	普通的对象引用

表格：FinalizationRegistry 的作用

作用	描述
监听回收	监听对象被垃圾回收器回收的事件
执行回调	当对象被回收时，执行回调函数
资源清理	在回调函数中释放资源，比如文件句柄、网络连接等

结束语：优雅地告别内存泄漏

WeakRef 和 FinalizationRegistry 是 JavaScript 中强大的工具，可以帮助我们优雅地处理资源管理问题，避免内存泄漏。虽然它们的使用需要谨慎，但掌握它们可以让我们写出更健壮、更可靠的代码。

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

发表回复 取消回复

发表回复取消回复