javascript - 实例化Node.js中的对象时防止踩踏

在NodeJS中使用Google Cloud服务时，我必须访问存储桶等资源（在存储中），并且首次调用它们时，必须检查它们是否存在，如果不存在，请创建它们。

好吧，如果多个资源在应用程序启动时访问同一存储桶，则它们将尝试同时创建它。

为了防止踩踏，我必须使用以下方法：

getStorage(id) {
    return new Promise((resolve, reject) => {

        // Exists storage?
        if(id in this.storage) {
            let storage = this.storage[id];

            // Storage is ready, deliver
            if(storage.ready) {
                return resolve(storage);
            }

            // Not ready, wait until storage is ready
            let wait;
            let start = +Date.now();

            wait = setInterval(() => {
                // Storage is now ready
                if(storage.ready) {
                    clearInterval(wait);
                    return resolve(storage);
                }

                // Timeout in 15 seconds
                if(+Date.now() - start > 15*1000) {
                    clearInterval(wait);
                    return reject(new Error('timeout while waiting storage creation'));
                }
            }, 10);

            return;
        }

        // Start storage creation
        let storage = new Storage(id);

        this.storage[id] = storage;

        storage
            .create()
            .then(resolve, reject);
    });
}

在lodash，下划线或异步中是否有任何有助于这种情况的内容？实例踩踏场景。

信号量会有用吗？

在异步风格中，可能是这样的：

getStorage(id) {
    return new Promise((resolve, reject) => {
        // already found
        if(id in this.storage) {
            resolve(this.storage[id]);
            return;
        }

        // prevent stampede

        // async.stampede( UNIQUE_ID, CREATE, RESULT )
        // - CREATE will be called once for UNIQUE_ID

        async.stampede(id, (end) => {
            let storage = new Storage(id);

            storage
                .create()
                .then(
                    () => end(null, storage),
                    (err) => end(err)
                );

        }, (err, result) => {
            if(err) reject(err);
            else {
                this.storage[id] = storage;
                resolve(result);
            }
        });
    });
}

在lodash中，它可能像“一次”但带有承诺。

最佳答案

您不需要任何信号量或对诺言的特殊处理。 Promise是代表异步结果的值，您可以简单地直接对其进行缓存。您不想要once之类的东西，而恰恰想要once。您再也不需要了。

或者实际上，由于要基于id参数缓存它们，因此需要使用Underscore / Lodash中的memoize：

getStorage: _.memoize(id => new Storage(id).create())

或没有图书馆而写的

getStorage(id) {
    // Exists storage?
    if (id in this.storage) {
        return this.storage[id]; // it's a promise
    } else {
        // Start storage creation
        let storage = new Storage(id);
        let promise = storage.create();
        this.storage[id] = promise; // store the promise!
        return promise;
    }
}

确保避免Promise constructor antipattern！

关于javascript - 实例化Node.js中的对象时防止踩踏，我们在Stack Overflow上找到一个类似的问题：https://stackoverflow.com/questions/41085713/