狠狠色丁香婷婷综合尤物/久久精品综合一区二区三区/中国有色金属学报/国产日韩欧美在线观看 - 国产一区二区三区四区五区tv

在 JavaScript 的異步編程世界中，Promise 扮演著至關重要的角色。它允許我們以更優雅的方式處理異步操作，但默認情況下，Promise 并不提供并發限制。本文將深入探討 Promise 的并發特性，解釋為什么需要并發限制，并提供幾種實現并發控制的方法。

Promise 的并發特性

立即執行

Promise 的一個顯著特點是，一旦創建，其中的執行函數會立即被調用。這意味著，即使你稍后調用.then()，異步操作已經開始執行。例如：

const promise = new Promise((resolve) => {
  console.log('Executing');
  resolve();
});

// 輸出: 'Executing'

無內置并發限制

當批量創建多個 Promise 時，所有任務會立即啟動，不會限制同時進行的任務數。這可能導致資源的過度消耗，尤其是在大量并發請求時。

const tasks = Array.from({ length: 10 }, (_, i) =>
  new Promise((resolve) => {
    setTimeout(() => {
      console.log(`Task ${i} done`);
      resolve();
    }, 1000);
  })
);

Promise.all(tasks).then(() => console.log('All tasks done'));

為何需要并發限制？

1. 「資源限制」: 系統資源（如網絡請求、文件句柄、內存）是有限的。同時運行過多任務可能導致性能下降，甚至任務失敗。

2. 「API 限制」:某些第三方 API 或服務可能對請求頻率或并發量有限制。

3. 「用戶體驗」:在前端應用中，過多的并發操作可能會影響頁面流暢性或加載速度。

如何實現 Promise 并發限制？

1：使用手動隊列管理

通過維護一個任務隊列和一個計數器，可以控制同時執行的任務數量。以下是一個簡單的實現：

function promiseWithConcurrencyLimit(tasks, limit) {
  const results = [];
  let activeCount = 0;
  let index = 0;
  return new Promise((resolve, reject) => {
    function next() {
      if (index === tasks.length && activeCount === 0) {
        return resolve(results);
      }
      while (activeCount < limit && index < tasks.length) {
        const taskIndex = index++;
        const task = tasks[taskIndex];
        activeCount++;
        task().then((result) => {
          results[taskIndex] = result;
        }).catch(reject).finally(() => {
          activeCount--;
          next();
        });
      }
    }
    next();
  });
}

2：使用第三方庫

如果不想手動實現，可以使用成熟的第三方庫，如p-limit。它提供了簡單易用的 API 來限制并發。

const pLimit = require('p-limit');
const limit = pLimit(3); // 限制并發為 3
const tasks = Array.from({ length: 10 }, (_, i) => () =>
  new Promise((resolve) =>
    setTimeout(() => {
      console.log(`Task ${i} done`);
      resolve(i);
    }, 1000)
  )
);

Promise.all(tasks.map((task) => limit(task))).then((results) => {
  console.log('All tasks done:', results);
});

3：利用異步生成器

通過異步生成器（async/await）和控制并發量的邏輯，可以實現更直觀的代碼流：

async function promiseWithConcurrencyLimit(tasks, limit) {
  const results = [];
  const executing = [];
  for (const task of tasks) {
    const promise = task();
    results.push(promise);
    executing.push(promise);
    if (executing.length >= limit) {
      await Promise.race(executing);
      executing.splice(executing.findIndex((p) => p === promise), 1);
    }
  }
  await Promise.all(executing);
  return Promise.all(results);
}

總結

• 「Promise 本身無并發限制」，但通過隊列、第三方庫或異步生成器等方法，可以靈活地實現并發控制。
• 「選擇適合的實現方式」：對于簡單場景可以手動實現隊列管理，而復雜項目中則推薦使用第三方庫。
• 「最佳實踐」:根據實際場景合理設置并發限制，以平衡資源利用和性能。

希望本文能幫助你理解 Promise 的并發控制及其重要性！