javascript怎么实现数组引用计数

WeakMap

class ResourceManager {
    constructor() {
        // 使用WeakMap，如果数组本身没有其他强引用，即使在管理器中，也能被GC回收
        // 但如果你的场景是管理器本身需要“拥有”数组的生命周期，可以使用Map
        this.resourceCounts = new WeakMap();
        this.cleanUpCallbacks = new WeakMap(); // 存储资源清理时的回调
    }

    /**
     * 获取或注册一个资源（数组），并增加其引用计数。
     * @param {Array} resource - 要管理的数组资源。
     * @param {Function} [cleanupFn] - 当引用计数归零时执行的清理函数。
     * @returns {Array} 传入的资源本身。
     */
    acquire(resource, cleanupFn = null) {
        if (!Array.isArray(resource)) {
            console.warn("ResourceManager: Only arrays are supported for now.");
            return resource;
        }

        let count = this.resourceCounts.get(resource) || 0;
        this.resourceCounts.set(resource, count + 1);

        if (cleanupFn && !this.cleanUpCallbacks.has(resource)) {
            this.cleanUpCallbacks.set(resource, cleanupFn);
        }
        console.log(`资源引用计数增加: ${resource} -> ${this.resourceCounts.get(resource)}`);
        return resource;
    }

    /**
     * 释放一个资源（数组），减少其引用计数。
     * 当计数归零时，执行清理回调。
     * @param {Array} resource - 要释放的数组资源。
     * @returns {boolean} 是否成功释放并可能触发清理。
     */
    release(resource) {
        if (!Array.isArray(resource)) {
            console.warn("ResourceManager: Only arrays are supported for now.");
            return false;
        }

        let count = this.resourceCounts.get(resource);
        if (typeof count === 'undefined' || count <= 0) {
            console.warn(`尝试释放未被跟踪或已归零的资源: ${resource}`);
            return false;
        }

        this.resourceCounts.set(resource, count - 1);
        console.log(`资源引用计数减少: ${resource} -> ${this.resourceCounts.get(resource)}`);

        if (this.resourceCounts.get(resource) === 0) {
            console.log(`资源引用计数归零，执行清理: ${resource}`);
            const cleanup = this.cleanUpCallbacks.get(resource);
            if (cleanup) {
                cleanup(resource);
                this.cleanUpCallbacks.delete(resource); // 清理回调函数
            }
            this.resourceCounts.delete(resource); // 从管理器中移除
            return true;
        }
        return false;
    }

    /**
     * 获取一个资源的当前引用计数。
     * @param {Array} resource - 要查询的数组资源。
     * @returns {number} 引用计数，如果未被跟踪则返回0。
     */
    getRefCount(resource) {
        return this.resourceCounts.get(resource) || 0;
    }
}

// 示例用法
const resourceManager = new ResourceManager();

const largeDataArray = [/* 假设这里有大量数据 */];
const anotherArray = [1, 2, 3];

// 模块A使用largeDataArray
resourceManager.acquire(largeDataArray, (res) => {
    console.log(`清理回调：大型数据数组 ${res} 已被完全释放，可以执行内存清理或缓存删除。`);
}); 
console.log('模块A开始使用largeDataArray');

// 模块B也使用largeDataArray
resourceManager.acquire(largeDataArray);
console.log('模块B开始使用largeDataArray');

// 模块C使用另一个数组
resourceManager.acquire(anotherArray, (res) => {
    console.log(`清理回调：另一个数组 ${res} 已被完全释放。`);
});
console.log('模块C开始使用anotherArray');

console.log(`largeDataArray当前引用计数: ${resourceManager.getRefCount(largeDataArray)}`); // 2
console.log(`anotherArray当前引用计数: ${resourceManager.getRefCount(anotherArray)}`); // 1

// 模块A不再需要largeDataArray
resourceManager.release(largeDataArray);
console.log('模块A停止使用largeDataArray');

// 模块C不再需要anotherArray
resourceManager.release(anotherArray); // 此时会触发anotherArray的清理回调
console.log('模块C停止使用anotherArray');

// 模块B不再需要largeDataArray
resourceManager.release(largeDataArray); // 此时会触发largeDataArray的清理回调
console.log('模块B停止使用largeDataArray');

console.log(`largeDataArray最终引用计数: ${resourceManager.getRefCount(largeDataArray)}`); // 0
console.log(`anotherArray最终引用计数: ${resourceManager.getRefCount(anotherArray)}`); // 0

malloc

free