你能在不使用 Deferred 的情况下写这个吗？

Question

我在下面编写了一些使用 Promise 的代码，我能找到的最简单的编写方法是使用 Deferred 对象而不是通常的 Promise 执行器函数，因为我需要从执行器外部解析 Promise。我想知道是否有一个基于 Promise 执行器函数的公认设计模式来解决这样的问题，它不使用类似延迟的解决方案？是否可以在无需从 Promise Executor 外部解决 Promise 的情况下完成？

这里是详细信息。

我有一个项目使用一组工作线程和想要不时使用工作线程的代码的各个部分。为了管理它，我创建了一个简单的WorkerList 类，它保留了可用工作线程的列表。当有人想要使用一个时，他们会调用get() 并返回一个解析为工作线程的承诺。如果工作线程立即可用，则承诺立即解决。如果所有工作线程都在使用中（因此可用工作线程列表为空），则承诺不会解析，直到稍后通过add(worker) 方法将一个返回可用列表。

这个 WorkerList 类只有两个方法，add(worker) 和 get()。你get() 一个工人，当你完成它时，你add(worker) 它回来了。当您add(worker) 回来时，该类会检查是否有任何任务在等待可用的 Worker。如果有，它会通过可用的 Worker 解决他们的承诺。解决其他人的承诺就是使用 Deferred 的地方。

这是WorkerList的代码：

class WorkerList {
    constructor() {
        this.workers = [];
        this.deferredQueue = [];
    }
    add(worker) {
        this.workers.push(worker);

        // if someone is waiting for a worker,
        // pull the oldest worker out of the list and
        // give it to the oldest deferred that is waiting
        while (this.deferredQueue.length && this.workers.length) {
            let d = this.deferredQueue.shift();
            d.resolve(this.workers.shift());
        }
    }
    // if there's a worker, get one immediately
    // if not, return a promise that resolves with a worker
    //    when next one is available
    get() {
        if (this.workers.length) {
            return Promise.resolve(this.workers.shift());
        } else {
            let d = new Deferred();
            this.deferredQueue.push(d);
            return d.promise;
        }
    }
}

还有，这里是延迟的实现：

function Deferred() {
    if (!(this instanceof Deferred)) {
        return new Deferred();
    }
    const p = this.promise = new Promise((resolve, reject) => {
        this.resolve = resolve;
        this.reject = reject;
    });
    this.then = p.then.bind(p);
    this.catch = p.catch.bind(p);
    if (p.finally) {
        this.finally = p.finally.bind(p);
    }
}

Answer 1

这是一种解决方案，它不会在 Promise executor 函数之外的任何地方公开 Promise 解析器函数。

在我对我自己关于基于事件的解决方案的问题的评论之后，这就是我想出的。它使用触发事件和事件侦听器在 promise 执行器函数中触发操作。

class WorkerList extends EventEmitter {
    constructor() {
        this.workers = [];
    }
    add(worker) {
        this.workers.push(worker);
        // notify listeners that there's a new worker in town
        this.emit('workerAdded');
    }
    // if there's a worker, get one immediately
    // if not, return a promise that resolves with a worker
    //    when next one is available
    get() {
        if (this.workers.length) {
            return Promise.resolve(this.workers.shift());
        } else {
            return new Promise(resolve => {
                const onAdded = () => {
                    if (this.workers.length) {
                        this.off('workerAdded', onAdded);
                        resolve(this.workers.shift());
                    }
                }

                this.on('workerAdded', onAdded);
            });
        }
    }
}

我最初担心维护 FIFO 排序，以便第一个调用 get() 的人获得下一个可用的工作人员。但是，因为 eventListeners 是按照添加的顺序调用的，所以我认为这实际上会实现 FIFO 顺序。如果有多个对get() 的调用，他们都会收到关于workerAdded 的通知，但是在第一个处理消息并带走工人之后，其他人会发现没有工人留给他们，因此他们的听众将保持连接状态等待未来的workerAdded 消息，当他们有工作人员时（当他们的听众排在第一位时）。

我认为我不一定比显示的其他选项更喜欢这个，但它是一种替代方法，不使用 Deferreds，甚至不将 resolve 处理程序暴露在 executor 函数之外。

---

正如建议的那样，这也可以在 eventEmitter 是实例变量而不是基类的情况下完成：

class WorkerList {
    constructor() {
        this.workers = [];
        this.emitter = new EventEmitter();
    }
    add(worker) {
        this.workers.push(worker);
        // notify listeners that there's a new worker in town
        this.emitter.emit('workerAdded');
    }
    // if there's a worker, get one immediately
    // if not, return a promise that resolves with a worker
    //    when next one is available
    get() {
        if (this.workers.length) {
            return Promise.resolve(this.workers.shift());
        } else {
            return new Promise(resolve => {
                const onAdded = () => {
                    if (this.workers.length) {
                        this.emitter.off('workerAdded', onAdded);
                        resolve(this.workers.shift());
                    }
                }

                this.emitter.on('workerAdded', onAdded);
            });
        }
    }
}

Answer 2

也许下面只是一个穷人处理延迟的方法，并没有真正解决问题的关键，但是你可以保留一个解析器函数队列，而不是延迟队列。

与您的方法相比，这会节省少量代码，并避免显式使用 Deferreds。

我不知道是否有一个既定的模式，但这本身似乎是一种用于维护异步对象池的可重用模式，因此与其将其命名为 WorkerList，不如将​​其命名为 AsyncPool ，然后在您的WorkerList 中将其组合为可重复使用的部分：

class AsyncPool {
    constructor() {
        this.entries = [];
        this.resolverQueue = [];
    }
    add(entry) {
        console.log(`adding ${entry}`);
        this.entries.push(entry);

        // if someone is waiting for an entry,
        // pull the oldest one out of the list and
        // give it to the oldest resolver that is waiting
        while (this.resolverQueue.length && this.entries .length) {
            let r = this.resolverQueue.shift();
            r(this.entries.shift());
        }
    }
    // if there's an entry, get one immediately
    // if not, return a promise that resolves with an entry
    //    when next one is available
    get() {
        return new Promise((r) => 
            this.entries.length
                ? r(this.entries.shift())
                : this.resolverQueue.push(r)
        );
    }
}


let pool = new AsyncPool();

pool.add('Doc');
pool.add('Grumpy');
pool.get().then(console.log);
pool.get().then(console.log);
pool.get().then(console.log);
pool.get().then(console.log);

// add more entries later
setTimeout(() => pool.add('Sneezy'), 1000);
setTimeout(() => pool.add('Sleepy'), 2000);