在我正在处理的项目中，使用 nodejs 和 mongo 构建，有一个函数接受查询并根据提供给它的限制和偏移量返回数据集。与此数据一起，该函数返回一个总计数，说明数据库中存在的所有匹配对象。下面是函数:

// options carry the limit & offset values
// mongoQuery carries a mongo matching query
function findMany(query, options, collectionId) {
    const cursor = getCursorForCollection(collectionId).find(query, options);
    return Promise.all([findManyQuery(cursor), countMany(cursor)]);
}

现在的问题是有时当我给出一个大的限制尺寸时我得到一个错误提示:

Uncaught exception:  TypeError: Cannot read property '_killCursor' of undefined

起初我以为我可能必须增加池大小才能解决此问题，但在深入研究之后我发现上述代码导致了竞争条件。当我将代码更改为:

function findMany(query, options, collectionId) {
  const cursor = getCursorForCollection(collectionId).find(query, options);
  return findManyQuery(cursor).then((dataSet) => {
    return countMany(cursor).then((count)=> {
      return Promise.resolve([dataSet, count]);
    });
  );
}

一切都开始工作得很好。现在，根据我对 Promise.all 的理解，它需要一系列 promise 并一个接一个地解决它们。如果 promise 一个接一个地执行，那么 Promise.all 代码怎么会导致竞争条件，而 promise 的链接不会导致这种情况。

我无法理解它。为什么会这样？

最佳答案

由于我可使用的信息很少，所以我假设了您想要实现的目标，并使用 Promise.all() 提出了以下内容，只是为了演示您应该如何使用 Promise.all(这将解决传递给它的 promise 数组没有特定的顺序。因此，任何 promise 都不能依赖于 promise 的执行顺序。Read more about it here)。

// A simple function to sumulate findManyQuery for demo purposes

function findManyQuery(cursors) {
    return new Promise((resolve, reject) => {
        // Do your checks and run your code (for example)
        if (cursors) {
            resolve({ dataset: cursors });
        } else {
            reject({ error: 'No cursor in findManyQuery function' });
        }

    });
}


// A simple function to sumulate countMany for demo purposes

function countMany(cursors) {
    return new Promise((resolve, reject) => {
        // Do your checks and run your code (for example)
        if (cursors) {
            resolve({ count: cursors.length });
        } else {
            reject({ error: 'No cursor in countMany' });
        }
    });
}

// A simple function to sumulate getCursorForCollection for demo purposes

function getCursorForCollection(collectionId) {
   /* 
        Simulating the returned cursor using an array of objects 
        and the Array filter function
    */

    return [{
        id: 1,
        language: 'Javascript',
        collectionId: 99
    }, {
        id: 2,
        language: 'Dart',
        collectionId: 100
    },
    {
        id: 3,
        language: 'Go',
        collectionId: 100
    }, {
        id: 4,
        language: 'Swift',
        collectionId: 99
    }, {
        id: 5,
        language: 'Kotlin',
        collectionId: 101
    },
    {
        id: 6,
        language: 'Python',
        collectionId: 100
    }].filter((row) =>  row.collectionId === collectionId)
}

function findMany(query = { id: 1 }, options = [], collectionId = 0) {

    /*  
         First I create a function to simulate the assumed use of 
         query and options parameters just for demo purposes
     */

    const filterFunction = function (collectionDocument) {
        return collectionDocument.collectionId === query.id && options.indexOf(collectionDocument.language) !== -1;
    };

    /*  
         Since I am working with arrays, I replaced find function 
         with filter function just for demo purposes
     */

    const cursors = getCursorForCollection(collectionId).filter(filterFunction);

    /* 
       Using Promise.all([]). NOTE: You should pass the result of the
       findManyQuery() to countMany() if you want to get the total 
       count of the resulting dataset
    */

    return Promise.all([findManyQuery(cursors), countMany(cursors)]);
}


// Consuming the findMany function with test parameters

const query = { id: 100 };
const collectionId = 100;
const options = ['Javascript', 'Python', 'Go'];

findMany(query, options, collectionId).then(result => {
    console.log(result); // Result would be [ { dataset: [ [Object], [Object] ] }, { count: 2 } ]
}).catch((error) => {
    console.log(error);
});

关于javascript - 使用 Promise.all 时可能出现游标竞争情况，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/57779327/