Node.js 垃圾收集和同步对象

Question

这有点难以解释，但我会试一试：

在 node.js 服务器应用程序中，我想处理一次可以在多个地方使用的数据对象。主要问题是，这些对象仅由对象 id 引用，并且是从数据库中加载的。

但是，一旦一个对象已经加载到一个作用域中，它就不应在请求时再次加载，而应返回相同的对象。

这让我想到了垃圾回收的问题：一旦某个对象在任何范围内不再需要，就应该完全释放它，以防止整个数据库一直在服务器的内存中。但问题就从这里开始：

我可以想到两种方法来创建这样的场景：要么使用全局对象引用（这会阻止任何对象被收集），要么真的复制这些对象，但以每次在其中的属性时同步它们的方式一个范围发生更改，通知其他实例有关该更改。

同样，因此每个实例都必须注册一个事件处理程序，该事件处理程序反过来又指向该实例，从而防止它再次被收集。

有没有人为我没有意识到的这种情况提出解决方案？还是我对垃圾收集器的理解有什么误解？

我要避免的是对内存中的每个对象进行手动引用计数。每次从任何集合中删除对象时，我都必须手动调整引用计数（js 中甚至没有析构函数或“引用减少”事件）

Answer 1

使用weak 模块，我实现了一个WeakMapObj，就像我们最初希望WeakMap 一样工作。它允许您对键使用原语，对数据使用对象，并且使用弱引用保留数据。并且，当它们的数据被 GCed 时，它会自动从地图中删除项目。结果证明是相当简单的。

const weak = require('weak');

class WeakMapObj {
    constructor(iterable) {
        this._map = new Map();
        if (iterable) {
            for (let array of iterable) {
                this.set(array[0], array[1]);
            }
        }
    }

    set(key, obj) {
        if (typeof obj === "object") {
            let ref = weak(obj, this.delete.bind(this, key));
            this._map.set(key, ref);
        } else {
            // not an object, can just use regular method
            this._map.set(key, obj);
        }
    }

    // get the actual object reference, not just the proxy
    get(key) {
        let obj = this._map.get(key);
        if (obj) {
            return weak.get(obj);
        } else {
            return obj;
        }
    }

    has(key) {
        return this._map.has(key);
    }

    clear() {
        return this._map.clear();
    }

    delete(key) {
        return this._map.delete(key);
    }
}

我能够在测试应用程序中对其进行测试，并确认它在垃圾收集器运行时按预期工作。仅供参考，仅使一两个对象符合垃圾收集条件并不会导致垃圾收集器在我的测试应用程序中运行。我不得不强行调用垃圾收集器才能看到效果。我认为这在真正的应用程序中不会成为问题。 GC 将在需要时运行（它可能仅在有合理的工作量时运行）。

---

您可以使用这个更通用的实现作为对象缓存的核心，其中项目将保留在 WeakMapObj 中，直到它不再被其他地方引用。

---

这是一个使地图完全私有的实现，因此无法从WeakMapObj 方法之外访问它。

const weak = require('weak');

function WeakMapObj(iterable) {
    // private instance data
    const map = new Map();

    this.set = function(key, obj) {
        if (typeof obj === "object") {
            // replace obj with a weak reference
            obj = weak(obj, this.delete.bind(this, key));
        }
        map.set(key, obj);

    }

    // add methods that have access to "private" map
    this.get = function(key) {
        let obj = map.get(key);
        if (obj) {
            obj = weak.get(obj);
        }
        return obj;
    }

    this.has = function(key) {
        return map.has(key);
    }

    this.clear = function() {
        return map.clear();
    }

    this.delete = function(key) {
        return map.delete(key);
    }

    // constructor implementation    
    if (iterable) {
        for (let array of iterable) {
            this.set(array[0], array[1]);
        }
    }
}

Answer 2

听起来像是Map 对象的作业，该对象用作缓存，将对象存储为值（连同计数），并将 ID 作为键。当你想要一个对象时，你首先在Map 中查找它的 ID。如果在那里找到它，则使用返回的对象（将由所有人共享）。如果在那里找不到，则从数据库中获取它并将其插入Map（供其他人查找）。

然后，为了使Map 不会永远增长，从Map 获取某些内容的代码还需要从Map 释放一个对象。当 useCnt 在发布时变为零时，您将从 Map 中删除一个对象。

这可以通过创建某种包含Map的cache对象对调用者完全透明，并具有获取对象或释放对象的方法，它将完全负责维护refCnt在Map 中的每个对象上。

注意：您可能必须仔细编写从数据库中获取数据并将其插入Map 的代码，以免产生竞争条件，因为从数据库中获取数据可能是异步的，您可能会获得多个调用者都没有在Map 中找到它，并且都在从数据库中获取它的过程中。如何避免这种竞争条件取决于您拥有的确切数据库以及您如何使用它。一种可能性是第一个调用者在Map 中插入一个占位符，这样后续调用者就会知道在对象插入Map 并可供他们使用之前等待一些承诺解决。

以下是关于 ObjCache 如何工作的总体思路。当你想检索一个项目时，你调用cache.get(id)。这总是返回一个解析为对象的承诺（或者如果从数据库中获取它时出错，则拒绝）。如果对象已经在缓存中，它返回的 promise 将已经被解析。如果对象尚未在缓存中，则当从数据库中获取该对象时，promise 将解析。即使您的代码的多个部分请求一个“正在”从数据库中获取的对象，这也有效。当从数据库中检索到对象时，它们都会得到相同的承诺，即使用相同的对象解决。每次调用cache.get(id) 都会增加缓存中该对象的refCnt。

然后，当给定的一段代码对对象完成时，您调用cache.release(id)。如果refCnt 达到零，这将减少内部refCnt 并从缓存中删除对象。

class ObjCache() {
    constructor() {
        this.cache = new Map();
    }
    get(id) {
        let cacheItem = this.cache.get(id);
        if (cacheItem) {
            ++cacheItem.refCnt;
            if (cacheItem.obj) {
                // already have the object
                return Promise.resolve(cacheItem.obj);
            }
            else {
                // object is pending, return the promise
                return cacheItem.promise;
            }
        } else {
            // not in the cache yet
            let cacheItem = {refCnt: 1, promise: null, obj: null};
            let p = myDB.get(id).then(function(obj) {
                // replace placeholder promise with actual object
                cacheItem.obj = obj;
                cacheItem.promise = null;
                return obj;
            });
            // set placeholder as promise for others to find
            cacheItem.promise = p;
            this.cache.set(id, cacheItem);
            return p;

        }
    }
    release(id) {
        let cacheItem = this.cache.get(id);
        if (cacheItem) {
            if (--cacheItem.refCnt === 0) {
                this.cache.delete(id);
            }
        }
    }
}

Answer 3

好的，对于任何面临类似问题的人，我找到了解决方案。 jfriend00 通过提到 WeakMaps 将我推向了这个解决方案，这本身并不完全是解决方案，而是将我的注意力集中在弱引用上。

有一个简单称为weak 的 npm 模块可以解决问题。它持有一个对象的弱引用，并在对象被垃圾回收后安全地返回一个空对象（因此，有一种方法可以识别回收的对象）。

所以我使用DataObject 创建了一个名为WeakCache 的类：

class DataObject{

    constructor( objectID ){
        this.objectID = objectID;
        this.dataLoaded = new Promise(function(resolve, reject){
            loadTheDataFromTheDatabase(function(data, error){ // some pseudo db call
                if (error)
                {
                    reject(error);
                    return;
                }

                resolve(data);
            }); 
        });
    }

    loadData(){
        return this.dataLoaded;
    }   
}

class WeakCache{

    constructor(){
        this.cache = {};
    }

    getDataObjectAsync( objectID, onObjectReceived ){
        if (this.cache[objectID] === undefined || this.cache[objectID].loadData === undefined){ // object was not cached yet or dereferenced, recreate it

            this.cache[objectID] = weak(new DataObject( objectID )function(){
                // Remove the reference from the cache when it got collected anyway
                delete this.cache[this.objectID];
            }.bind({cache:this, objectID:objectID});
        }

        this.cache[objectID].loadData().then(onObjectReceived);
    }

}

这门课仍在进行中，但至少这是它可以工作的一种方式。唯一的缺点（但对于所有基于数据库的数据都是如此，双关语警告！因此没什么大不了的）是所有数据访问都必须是异步的。

这里会发生什么，缓存在某些时候可能对每个可能的对象 id 都持有一个空引用。