Có một đoạn code nhìn vô hại đến mức review xong ai cũng bấm approve: lấy 10.000 user từ DB, rồi Promise.all(users.map(sendEmail)). Chạy trên máy local với 20 record thì mượt. Lên production thì connection pool cạn, API upstream trả 429 hàng loạt, và RAM nhảy vọt. Lỗi không nằm ở Promise.all, mà ở chỗ mình hiểu nó sai.
Promise.all không "chạy song song có kiểm soát"
Promise.all không hề điều phối gì cả. Lúc bạn gọi users.map(sendEmail), 10.000 lời gọi đã được khởi động ngay lập tức, Promise.all chỉ ngồi chờ kết quả. Nghĩa là 10.000 socket, 10.000 query, 10.000 buffer cùng lúc nằm trong bộ nhớ.
Ảnh: hàng nghìn chiếc thuyền giấy chen vào một cổng kênh hẹp — chính là 10.000 promise cùng lao vào connection pool chỉ có vài chục slot, kẹt cứng và chờ nhau — ảnh minh hoạ do AI tạo (Grok Imagine)
Triệu chứng hay gặp: lỗi ECONNRESET, too many clients từ Postgres, hoặc timeout dây chuyền. Mình từng gặp đúng ca này khi chạy job gửi thông báo, và nó giống hệt câu chuyện của fetch treo vô hạn: không có giới hạn nào ở giữa thì mọi thứ đổ dồn về chỗ yếu nhất.
Cách đơn giản nhất: chia lô (batch)
Cách thô mà vẫn hiệu quả: cắt mảng thành từng lô, mỗi lô chạy Promise.all, xong lô này mới sang lô sau.
async function inBatches(items, size, worker) {
const results = [];
for (let i = 0; i < items.length; i += size) {
const batch = items.slice(i, i + size);
results.push(...(await Promise.all(batch.map(worker))));
}
return results;
}
await inBatches(users, 20, sendEmail);
Nhược điểm: lô nào cũng phải chờ task chậm nhất. Nếu 19 task xong sau 100ms mà 1 task mất 5 giây, 19 slot ngồi không 4,9 giây. Với job lớn, throughput tụt thấy rõ.
Worker pool: luôn giữ N task đang chạy
Cách tốt hơn là dựng vài "worker", mỗi worker lấy việc kế tiếp ngay khi vừa xong việc cũ. Slot không bao giờ rảnh.
Ảnh: một trạm chắn chỉ cho vài quả cầu sáng đi qua cùng lúc trên băng chuyền — đúng tinh thần worker pool, luôn giữ N task đang chạy chứ không đổ hết một lượt — ảnh minh hoạ do AI tạo (Grok Imagine)
async function mapLimit(items, limit, worker) {
const results = new Array(items.length);
let next = 0;
async function run() {
while (true) {
const i = next++; // đồng bộ, không bị race trong 1 event loop
if (i >= items.length) return;
results[i] = await worker(items[i], i);
}
}
await Promise.all(Array.from({ length: Math.min(limit, items.length) }, run));
return results;
}
await mapLimit(users, 20, sendEmail);
Đoạn next++ an toàn vì JavaScript chạy đơn luồng: giữa hai lần await không ai chen vào được. Đây là một trong những lúc single thread làm đời dễ hơn hẳn so với Go hay Java.
Nếu không muốn tự viết, thư viện p-limit hoặc p-map làm đúng việc này và đã được test kỹ. Cho mảng thông thường thì pool tự viết 15 dòng là đủ dùng. Khi chạy nhiều task song song, nhớ gắn id vào log từng task, cách gọn nhất là AsyncLocalStorage để không phải truyền tham số khắp nơi mà vẫn truy vết được task nào lỗi.
Chọn limit bao nhiêu?
Đừng chọn số cho đẹp. Limit phải nhỏ hơn nút cổ chai thật sự:
- Gọi DB: không vượt quá kích thước pool (và chừa chỗ cho request khác của app).
- Gọi API bên thứ ba: theo quota của họ, thường 5–20.
- Việc CPU nặng: concurrency không giúp gì, hãy dùng worker thread.
Cách làm thực tế: bắt đầu với 10, đo throughput và tỉ lệ lỗi, tăng dần tới khi lỗi bắt đầu xuất hiện thì lùi lại một nấc.
Một task lỗi thì sao?
Promise.all reject ngay khi có một promise lỗi, nhưng không huỷ các task còn lại, chúng vẫn chạy ngầm. Với job gửi mail, thường bạn muốn đi tiếp và gom lỗi lại:
Ảnh: phòng điều khiển bình tĩnh, một quả cầu bị đánh dấu lỗi nhưng dòng chảy vẫn tiếp tục — tương ứng với việc gom lỗi từng task thay vì để một lỗi làm sập cả job — ảnh minh hoạ do AI tạo (Grok Imagine)
const failed = [];
await mapLimit(users, 20, async (u) => {
try {
await sendEmail(u);
} catch (err) {
failed.push({ id: u.id, reason: err.message });
}
});
console.log(`xong, lỗi ${failed.length}/${users.length}`);
Nếu muốn dừng hẳn khi gặp lỗi, truyền một AbortSignal vào worker và kiểm tra trước mỗi task, tương tự cách mình làm với timeout fetch. Còn ở thế giới async khác thì cái bẫy "chạy việc nặng giấu trong async" cũng không hiếm, như trường hợp Tokio chậm bất thường bên Rust.
Chốt lại
Promise.all(items.map(fn))= bắn hết một lượt, không có phanh.- Batch là cách nhanh để có phanh; worker pool mới giữ được throughput.
- Limit lấy từ nút cổ chai thật (pool DB, quota API), không phải số ngẫu nhiên.
- Quyết định trước: một task lỗi thì dừng cả job hay gom lỗi đi tiếp.
Lần tới thấy Promise.all bọc ngoài một .map trên dữ liệu không biết trước kích thước, bạn thử hỏi: "nếu mảng này có 100.000 phần tử thì sao?"
📋 Phụ lục thuật ngữ
| Thuật ngữ | Giải thích ngắn |
|---|---|
| Concurrency limit | Số task tối đa được chạy cùng lúc |
| Connection pool | Tập kết nối DB dùng chung, số lượng có hạn |
| Batch | Chia dữ liệu thành lô nhỏ, xử lý lần lượt từng lô |
| Worker pool | N worker cùng lấy việc từ một hàng đợi, xong việc nào lấy việc tiếp |
| Backpressure | Cơ chế làm chậm bên gửi khi bên nhận không theo kịp |
| 429 | Mã HTTP "Too Many Requests", server từ chối vì gọi quá nhiều |
