language-agnostic - 因未兑现 promise 而导致计划挂起的期限

Question

程序存在逻辑错误，导致 promise 永远不会被满足(或者如果您来自 Java 土地，则您的 Future is never Completed )。结果，程序挂起。

这种情况似乎可以推广到生产者-消费者，其中生产者忘记/丢失了一些东西。

您如何称呼这种情况？有一个术语或短语来描述它吗？

---

我认为死锁是不对的，因为我无法识别循环依赖( necessary conditions for deadlock 之一)。活锁似乎也不正确，因为线程并不竞争资源——它们只是无事可做。

我认为有些人确实将其称为死锁。如果有人能让我相信所有conditions for deadlock实际上遇到了这种情况，那么我认为这是一个令人满意的答案。

Answer 1

这称为活跃度问题。

由于代码中的不同问题，可能会出现多种不同的 Promise 活跃度问题。

^{图片取自here}

死锁

如果存在资源争用，并且两个或多个 Promise 持有另一个 Promise 需要进度但不释放它们的资源。当存在锁定时，就会发生这种情况。例如， promise 返回函数 P1 持有 mutex资源 A 和 P2 持有资源 B 的互斥体。为了前进，P1 需要获取 A 的锁，为了前进，P2 需要获取 A 的锁 - 所以两者都不能前进并释放锁。程序停止了。

var aPromise = Promise.resolve(); // empty promise
var bPromise = Promise.resolve(); // empty promise
function lockedResourceA(user){
   return aPromise = aPromise.then(user);
}
function lockedResourceB(user){
   return bPromise = bPromise.then(user);
}

现在，让我们陷入僵局:

lockedResourceA(function(a){
    return lockedResourceB(b){
        // do computation
    });
});

lockedResourceB(function(a){
    return lockedResourceA(b){
        // do computation
    });
});

这里计算可能永远不会进行。

活锁

An infinite loop prevents this incarnation of a vat from ever again making progress, just as it would prevent a conventional thread from making progress. As with conventional threads, it does not prevent other vats (threads) from making progress. Unfortunately, since each E object is in only one vat, livelocking a vat does lock up all objects within a vat. (This would be analogous to livelocking a thread that holds a synchronized lock on several objects.)

^source

这类似于死锁，只不过不是 promise “卡住”，而是每个 promise 都尝试产生下一个资源。例如，假设在上面的示例中， promise 返回函数不关心它们首先获得哪个资源 - 因此 P1 和 P2 每次都尝试生成一个资源，因此它们每个都获得一个交替资源，并且两者都没有完成，因为在每个回合中其中只有一件元素。

数据锁

这是一个无底的递归数据定义 - 例如，一个依赖于自身的 Promise 或多个相互依赖于彼此递归实现的 Promise。

例如:

var p = Promise.resolve().then(function(){ 
    return p; // datalock
});

Here is a full wrap up of this problem

网格锁

Technically, this looks like a classic deadlock, but it's caused specifically by lack of outgoing buffers. The distinction between deadlock and gridlock? If more buffer space would have caused you not to have locked up yet, then it's gridlock rather than deadlock.

^source

当您在 promise 队列中进行缓冲并且缓冲空间不足阻碍进度时，就会发生这种情况。这与流背压问题密切相关。

信号丢失

当您有 promise 但没有兑现或违反时，就会发生这种情况。

An example, due to Mark Seaborn (thanks!): If you have a when-catch "waiting" (posted as a callback) for a promise to be resolved, but in the code that's supposed to resolve it, you forget to call resolve in all applicable cases. Of course, actual lost signal bugs may be arbitrarily more complicated than this.

^source

例如:

var p = new Promise(function(resolve, reject){
    // never call resolve
});
p.then(function(){
    // never runs
});

这里是an excellent summary on the topic作者:马克·S·米勒。