如何并行执行更新

Question

我注意到，当我使用new Promise(async (resolve, reject)与new Promise((resolve, reject)) ，它正在执行查询，并且在Promise.all([]).then上获得了所需的结果Promise.all([]).then像这样阻塞：

      const borrowersFeePromise = new Promise(async (resolve, reject) => {
        if (borrowersFee !== undefined && borrowersFee !== '') {
          const borrowersFeeUpserted = await Fees.update(
            {
              personId: mongoose.Types.ObjectId(personId),
              category: 'borrowersFee',
            },
            {
              $set: {
                amount: borrowersFee,
              },
            },
            { upsert: true },
          );
          resolve({
            upsert: borrowersFeeUpserted,
            hasPassed: true,
          });
        } else {
          resolve({
            upsert: null,
            hasPassed: true,
          });
        }
      });

      const extendedFeePromise = new Promise(async (resolve, reject) => {
        if (extendedFee !== undefined && extendedFee !== '') {
          const extendedFeeUpserted = await Fees.update(
            {
              personId: mongoose.Types.ObjectId(personId),
              category: 'extendedFee',
            },
            {
              $set: {
                amount: extendedFee,
              },
            },
            { upsert: true },
          );
          resolve({
            upsert: extendedFeeUpserted,
            hasPassed: true,
          });
        } else {
          resolve({
            upsert: null,
            hasPassed: true,
          });
        }
      });

      await Promise.all([
        borrowersFeePromise,
        extendedFeePromise,
      ]).then((feesResult) => {
        console.log(feesResult);

        /*
          outputs something like:
          [ { upsert: { n: 1, nModified: 1, ok: 1 }, hasPassed: true },
            { upsert: { n: 1, nModified: 1, ok: 1 }, hasPassed: true } ]
        */
      });   

但是，当我只使用new Promise((resolve, reject) ，它不执行查询，并输出如下内容：

 [   { upsert:
    Query {
      _mongooseOptions: {},
      mongooseCollection: [Object],
      model: [Object],
      schema: [Object],
      op: 'update',
      options: [Object],
      _conditions: [Object],
      _fields: undefined,
      _update: [Object],
      _path: undefined,
      _distinct: undefined,
      _collection: [Object],
      _traceFunction: undefined,
      _count: [Function],
      _execUpdate: [Function],
      _find: [Function],
      _findOne: [Function],
      _findOneAndRemove: [Function],
      _findOneAndUpdate: [Function],
      _replaceOne: [Function],
      _updateMany: [Function],
      _updateOne: [Function] },
   hasPassed: true },
 ....]    

我以为promise是要等待执行的，但是为什么它只在async (resolve, reject)时才执行？ 我的意图是让这两项费用在我运行Promise.all时同时执行，就像非阻塞命令一样。 通过观看和重新观看有关Promises的教程，这就是我对它的理解。 我做错了吗？

非常感谢。

Answer 1

据我所知，这实际上是您想要的：

await Promise.all([
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'borrowersFee',
        },
        {
          $set: {
            amount: borrowersFee,
          },
        },
        { upsert: true },
  ),
  Fees.update(
        {
          personId: mongoose.Types.ObjectId(personId),
          category: 'extendedFee',
        },
        {
          $set: {
            amount: extendedFee,
          },
        },
        { upsert: true },
  )
])

但实际上，您应该这样做：

let results = await Fees.bulkWrite([
  { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'borrowersFee',
    },
    "update": { $set: { amount: borrowersFee } },
    "options": { upsert: true },
 }},
 { "updateOne": { 
    "filter": {
      personId: mongoose.Types.ObjectId(personId),
      category: 'extendedFee',
    },
    "update": { $set: { amount: extendedFee } },
    "options": { upsert: true },
 }}
],{ "ordered": false })

使用bulkWrite()方法意味着“一个”请求通过网络发送到服务器，而不是执行单独的语句以并行解析所需的“两个”请求。 因此，不仅减少了开销，使其更快，而且{ "ordered": false }确保它们实际上在“服务器上”并行运行。