你怎么知道一个无限长的承诺链何时完全结束？

Question

我试图使用 Promise 来强制序列化一系列 Ajax 调用。每次用户按下按钮时，都会进行一次这些 Ajax 调用。我可以成功序列化这样的操作：

// sample async function
// real-world this is an Ajax call
function delay(val) {
    log("start: ", val);
    return new Promise(function(resolve)  {
        setTimeout(function() {
            log("end: ", val); 
            resolve();
        }, 500);
    });
}

// initialize p to a resolved promise
var p = Promise.resolve();
var v = 1;

// each click adds a new task to 
// the serially executed queue
$("#run").click(function() {
    // How to detect here that there are no other unresolved .then()
    // handlers on the current value of p?
    p = p.then(function() {
        return delay(v++);
    });
});

工作演示：http://jsfiddle.net/jfriend00/4hfyahs3/

但是，这会构建一个可能永无止境的承诺链，因为存储最后一个承诺的变量 p 永远不会被清除。每一个新的操作都只是链接到先前的承诺。所以，我在想，为了良好的内存管理，我应该能够检测到何时没有更多的.then() 处理程序可以在p 的当前值上运行，然后我可以重置p 的值，使确保之前的 Promise 处理程序链可能在闭包中持有的任何对象都符合垃圾回收条件。

所以，我想知道如何在给定的.then() 处理程序中知道在此链中没有更多的.then() 处理程序可以调用，因此，我可以执行p = Promise.resolve() 来重置p 和释放之前的 Promise 链，而不是不断地添加它。

Answer 1

... 这样我就可以重置 p 的值，确保之前的承诺处理程序链可能在闭包中持有的任何对象都可以进行垃圾回收。

没有。已执行的 Promise 处理程序（当 Promise 已解决时）不再需要并且隐式符合垃圾收集的条件。已解决的 Promise 仅保留分辨率值。

您不需要为 Promise（异步值）执行“良好的内存管理”，您的 Promise 库会自行处理。它必须自动“释放先前的承诺链”，如果没有，那就是一个错误。您的模式完全可以正常工作。

---

你怎么知道承诺链何时完成？

我会为此采取纯粹的递归方法：

function extendedChain(p, stream, action) {
     // chains a new action to p on every stream event
     // until the chain ends before the next event comes
     // resolves with the result of the chain and the advanced stream
     return Promise.race([
         p.then(res => ({res}) ), // wrap in object to distinguish from event
         stream                   // a promise that resolves with a .next promise
     ]).then(({next, res}) =>
         next
           ? extendedChain(p.then(action), next, action) // a stream event happened first
           : {res, next:stream};                         // the chain fulfilled first
     );
}
function rec(stream, action, partDone) {
    return stream.then(({next}) =>
        extendedChain(action(), next, action).then(({res, next}) => {
            partDone(res);
            return rec(next, action, partDone);
        });
    );
}

var v = 1;
rec(getEvents($("#run"), "click"), () => delay(v++), res => {
    console.log("all current done, none waiting");
    console.log("last result", res);
}); // forever

带有事件流的辅助函数，例如

function getEvents(emitter, name) {
    var next;
    function get() {
        return new Promise((res) => {
            next = res;
        });
    }
    emitter.on(name, function() {
        next({next: get()});
    });
    return get();
}

(Demo at jsfiddle.net)

Answer 2

有人告诉我，“好的”承诺实现不会导致从无限增长的承诺链中积累内存。但是，显然没有标准要求或描述这一点（除了良好的编程实践），而且我们有很多新手 Promise 实现，所以我还没有决定依赖这种良好行为是否明智。

我多年的编码经验表明，当实现是新的时，缺乏所有实现都以特定方式运行并且没有规范说明它们应该以这种方式运行的事实，那么将代码编写为“安全”可能是明智的“尽可能的方式。事实上，仅仅围绕不确定的行为编写代码通常比测试所有相关实现以找出它们的行为方式要少。

在这方面，这是我的代码的一个实现，在这方面似乎是“安全的”。它只是为每个.then() 处理程序保存全局最后一个承诺变量的本地副本，并且当.then() 处理程序运行时，如果全局承诺变量仍然具有相同的值，那么我的代码没有将任何更多的项目链接到它上面所以这必须是当前最后一个 .then() 处理程序。它似乎在this jsFiddle 中工作：

// sample async function
// real-world this is an Ajax call
function delay(val) {
    log("start: ", val);
    return new Promise(function(resolve)  {
        setTimeout(function() {
            log("end: ", val); 
            resolve();
        }, 500);
    });
}

// initialize p to a resolved promise
var p = Promise.resolve();
var v = 1;

// each click adds a new task to 
// the serially executed queue
$("#run").click(function() {
    var origP = p = p.then(function() {
        return delay(v++);
    }).then(function() {
        if (p === origP) {
            // no more are chained by my code
            log("no more chained - resetting promise head");
            // set fresh promise head so no chance of GC leaks
            // on prior promises
            p = Promise.resolve();
            v = 1;
        }
        // clear promise reference in case this closure is leaked
        origP = null;
    }, function() {
        origP = null;
    });
});

Answer 3

无法检测到何时不再添加处理程序。

这实际上是一个不可判定的问题。显示停止（或Atm 问题）的减少并不是很困难。如果您愿意，我可以添加一个正式的缩减，但要手动添加：给定一个输入程序，在其第一行放置一个承诺，并在每个 return 或 throw 处链接它 - 假设我们有一个解决问题的程序您在这个问题中描述 - 将其应用于输入问题 - 我们现在知道它是否永远运行或没有解决停止问题。也就是说，您的问题至少与停机问题一样困难。

您可以检测承诺何时“解决”并更新新的承诺。

这在“last”或“flatMap”中很常见。一个很好的用例是自动完成搜索，您只需要最新的结果。这是 [Domenic 的实现 (https://github.com/domenic/last):

function last(operation) {
    var latestPromise = null; // keep track of the latest

    return function () {
        // call the operation
        var promiseForResult = operation.apply(this, arguments);
        // it is now the latest operation, so set it to that.
        latestPromise = promiseForResult;

        return promiseForResult.then(
            function (value) {
                // if we are _still_ the last value when it resovled
                if (latestPromise === promiseForResult) {
                    return value; // the operation is done, you can set it to Promise.resolve here
                } else {
                    return pending; // wait for more time
                }
            },
            function (reason) {
                if (latestPromise === promiseForResult) { // same as above
                    throw reason;
                } else {
                    return pending;
                }
            }
        );
    };
};

我改编了 Domenic 的代码并为您的问题记录了它。

你不能放心地优化它

理智的承诺实现不会遵守“链上”的承诺，因此将其设置为 Promise.resolve() 不会节省内存。如果一个 Promise 没有这样做，那就是内存泄漏，你应该针对它提交一个错误。

Answer 4

您可以将 Promise 推送到数组中并使用 Promise.all:

var p = Promise.resolve, 
   promiseArray = [], 
   allFinishedPromise;

function cleanup(promise, resolvedValue) {
    // You have to do this funkiness to check if more promises
    // were pushed since you registered the callback, though.
    var wereMorePromisesPushed = allFinishedPromise !== promise;
    if (!wereMorePromisesPushed) {
        // do cleanup
        promiseArray.splice(0, promiseArray.length);
        p = Promise.resolve(); // reset promise
    }
}

$("#run").click(function() {
    p = p.then(function() {
        return delay(v++);
    });
    promiseArray.push(p)
    allFinishedPromise = Promise.all(promiseArray);
    allFinishedPromise.then(cleanup.bind(null, allFinishedPromise));
});

或者，由于您知道它们是按顺序执行的，您可以让每个完成回调从数组中删除该承诺，并在数组为空时重置该承诺。

var p = Promise.resolve(), 
    promiseArray = [];

function onPromiseComplete() {
    promiseArray.shift();
    if (!promiseArray.length) {
        p = Promise.resolve();
    }
}

$("#run").click(function() {
    p = p.then(function() {
        onPromiseComplete();
        return delay(v++);
    });
    promiseArray.push(p);
});

编辑：但是，如果数组可能会变得很长，则应该使用第一个选项 b/c 将数组移动为 O(N)。

编辑： 正如您所指出的，没有理由保留数组。计数器可以正常工作。

var p = Promise.resolve(), 
    promiseCounter = 0;

function onPromiseComplete() {
    promiseCounter--;
    if (!promiseCounter) {
        p = Promise.resolve();
    }
}

$("#run").click(function() {
    p = p.then(function() {
        onPromiseComplete();
        return delay(v++);
    });
    promiseCounter++;
});

Answer 5

我试图检查我们是否可以在代码中看到承诺的状态，显然这只能从控制台而不是代码中看到，所以我使用了一个标志来监控状态，不确定某处是否存在漏洞：

  var p
    , v = 1
    , promiseFulfilled = true;



  function addPromise() {
    if(!p || promiseFulfilled){
      console.log('reseting promise...');
      p = Promise.resolve();
    }
    p = p.then(function() {
        promiseFulfilled = false;
        return delay(v++);
    }).then(function(){
      promiseFulfilled = true;
    });
  }

fiddle demo