如何使用p-limit限制并發數

這篇文章主要講解了“如何使用p-limit限制并發數”，文中的講解內容簡單清晰，易于學習與理解，下面請大家跟著小編的思路慢慢深入，一起來研究和學習“如何使用p-limit限制并發數”吧！

使用

下面是官方提供的使用示例：

import pLimit from 'p-limit';
const limit = pLimit(1);
const input = [
	limit(() => fetchSomething('foo')),
	limit(() => fetchSomething('bar')),
	limit(() => doSomething())
];
// Only one promise is run at once
const result = await Promise.all(input);
console.log(result);

在代碼的第一行，使用了 pLimit(1) 來創建一個 p-limit 實例，并將并發限制設為 1。這意味著，在任意時刻，只能有一個 Promise 在運行。

在第四行，使用了 limit(() => fetchSomething('foo')) 來包裝一個異步函數，并返回一個 Promise。同樣的方式，在第五、六行也包裝了其他兩個異步函數。

最后，使用 Promise.all 方法來等待所有 Promise 的完成，并在完成后將結果輸出到控制臺。由于 p-limit 的限制，這些 Promise 只會按順序一個一個地運行，保證了并發的數量不會超過 1。

源碼分析

import Queue from 'yocto-queue';
export default function pLimit(concurrency) {
	if (!((Number.isInteger(concurrency) || concurrency === Number.POSITIVE_INFINITY) && concurrency > 0)) {
		throw new TypeError('Expected `concurrency` to be a number from 1 and up');
	}
	const queue = new Queue();
	let activeCount = 0;
}

yocto-queue 是一種允許高效存儲和檢索數據的數據結構。前邊的章節分析過它的源碼，詳情參見： 源碼共讀|yocto-queue 隊列 鏈表

pLimit 函數接受一個參數，并發數，首先函數判斷參數是否是數組類型，或者是否能夠轉換成數字類型，如果不能，拋出一個錯誤。

之后定義了一個隊列來存儲待執行的函數，并使用一個計數器來記錄當前正在運行的函數的數量。

const next = () => {
		activeCount--;
		if (queue.size > 0) {
			queue.dequeue()();
		}
	};
	const run = async (fn, resolve, args) => {
		activeCount++;
		const result = (async () => fn(...args))();
		resolve(result);
		try {
			await result;
		} catch {}
		next();
	};

在代碼的 next 函數中，如果隊列不為空，則從隊列中取出一個函數并執行。這個函數的執行會導致計數器的值減 1。

在代碼的 run 函數中，使用了 async/await 語法來執行傳入的函數 fn。它還使用了 resolve 函數將函數的返回值包裝成一個 Promise，并將這個 Promise 返回給調用者。在函數執行完成后，調用 next 函數來執行下一個函數。

	const enqueue = (fn, resolve, args) => {
		queue.enqueue(run.bind(undefined, fn, resolve, args));
		(async () => {
			// This function needs to wait until the next microtask before comparing
			// `activeCount` to `concurrency`, because `activeCount` is updated asynchronously
			// when the run function is dequeued and called. The comparison in the if-statement
			// needs to happen asynchronously as well to get an up-to-date value for `activeCount`.
			await Promise.resolve();
			if (activeCount < concurrency && queue.size > 0) {
				queue.dequeue()();
			}
		})();
	};

在代碼的 enqueue 函數中，使用了 queue.enqueue 方法將傳入的函數 fn 加入隊列。然后，它使用了 async/await 語法來在下一個微任務中檢查當前的并發數量是否小于設定的并發限制。如果是，則從隊列中取出一個函數并執行。

	const generator = (fn, ...args) => new Promise(resolve => {
		enqueue(fn, resolve, args);
	});
	Object.defineProperties(generator, {
		activeCount: {
			get: () => activeCount,
		},
		pendingCount: {
			get: () => queue.size,
		},
		clearQueue: {
			value: () => {
				queue.clear();
			},
		},
	});
	return generator;

在代碼的 generator 函數中，使用了 new Promise 語法來生成一個新的 Promise，并在其中調用了 enqueue 函數。這樣，每次調用生成的函數時，都會生成一個新的 Promise，并將函數加入隊列。

最后，使用了 Object.defineProperties 方法來為生成的函數添加屬性。這些屬性可以用來查詢當前的并發數量和等待隊列的大小，以及清空等待隊列。

感謝各位的閱讀，以上就是“如何使用p-limit限制并發數”的內容了，經過本文的學習后，相信大家對如何使用p-limit限制并發數這一問題有了更深刻的體會，具體使用情況還需要大家實踐驗證。這里是億速云，小編將為大家推送更多相關知識點的文章，歡迎關注！