异步并发数量控制的最佳实践

2024-02-11 09:18:04

控制 Promise 并发数量的艺术

概述

在处理异步操作时，Promise 是JavaScript中一个强大的工具。然而，当我们处理大量并发 Promise 时，控制并发数量至关重要，以优化性能并防止系统过载。在这篇文章中，我们将探讨使用原生 Promise API、第三方库和自定义解决方案来控制 Promise 并发数量的方法。

原生 Promise API

原生 Promise API 提供了 Promise.all() 和 Promise.allSettled() 方法来处理并发 Promise。Promise.all() 会等待所有 Promise 完成并返回一个包含所有结果的数组，而 Promise.allSettled() 会等待所有 Promise 完成并返回一个包含所有结果和状态的数组。

尽管简单易用，但原生 Promise API 只允许控制并发数量的上限。它无法动态调整并发数量，这可能会限制其在某些情况下的灵活性。

// 使用 Promise.all() 控制并发数量
const promises = [];
for (let i = 0; i < 10; i++) {
  promises.push(
    new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(i);
      }, 1000);
    })
  );
}

Promise.all(promises.slice(0, 3)).then((results) => {
  console.log(results); // [0, 1, 2]
});

第三方库

第三方库，如 bluebird 和 concurrently，提供了更丰富的功能和更灵活的控制方式来管理 Promise 并发数量。这些库允许设置并发数量的上限和下限，动态调整并发数量，以及处理 Promise 失败的情况。

// 使用 bluebird 控制并发数量
const Bluebird = require('bluebird');

const promises = [];
for (let i = 0; i < 10; i++) {
  promises.push(
    new Promise((resolve, reject) => {
      setTimeout(() => {
        resolve(i);
      }, 1000);
    })
  );
}

Bluebird.map(promises, (promise) => {
  return promise;
}, { concurrency: 3 }).then((results) => {
  console.log(results); // [0, 1, 2]
});

第三方库比原生 Promise API 更复杂，但它们提供了更强大的功能和更灵活的控制选项。

自定义解决方案

使用自定义解决方案来控制 Promise 并发数量是最灵活的方法。它允许根据特定需求进行定制，但同时也是最复杂的方法。您可以使用队列、信号量或其他并发控制机制来实现此目的。

// 使用队列控制并发数量
class Queue {
  constructor(concurrency) {
    this.concurrency = concurrency;
    this.queue = [];
    this.running = 0;
  }

  add(task) {
    return new Promise((resolve, reject) => {
      this.queue.push({ task, resolve, reject });
      this.run();
    });
  }

  run() {
    while (this.running < this.concurrency && this.queue.length > 0) {
      const { task, resolve, reject } = this.queue.shift();
      this.running++;
      task().then((result) => {
        resolve(result);
        this.running--;
        this.run();
      }).catch((error) => {
        reject(error);
        this.running--;
        this.run();
      });
    }
  }
}

// 使用队列控制 Promise 并发数量
const queue = new Queue(3);

const promises = [];
for (let i = 0; i < 10; i++) {
  promises.push(
    queue.add(() => {
      return new Promise((resolve, reject) => {
        setTimeout(() => {
          resolve(i);
        }, 1000);
      });
    })
  );
}

Promise.all(promises).then((results) => {
  console.log(results); // [0, 1, 2]
});