4W 条数据笛卡尔积的内存流式处理

朋友曾经问过我一个问题:

“我现在有四万条数据,怎么把它们一次性放到 Node.js 内存里处理,才不会卡死或内存溢出?”

作为一名 Node.js 开发者,看到“把几万条数据全部塞入内存”这种提法,第一直觉通常是:先别急着放进内存,你的真实业务场景究竟是什么?

进一步沟通后,我才了解了具体需求:

  • 现有三类基础数据(分别保存在三个数组中),需要将它们按顺序组合,得到所有可能的结果;
  • 最终目标是:将所有组合结果作为参数,逐一向第三方接口发送网络请求。

把问题拆解开来就会发现:这根本不是一个“如何扩大内存容纳 4W 条数据”的硬件问题,而是一个**数学生成策略(笛卡尔积惰性求值)与异步 I/O 流量控制(并发与背压)**的工程问题。


一、数学概念辨析:是“排列组合”还是“笛卡尔积”?

在日常交流中,很多人习惯顺口把这种场景称为“排列组合”。但在离散数学与集合论中,两者的概念有着严格的区别:

  • 排列(Permutation)与组合(Combination):通常是从同一个集合中,按顺序或不按顺序选取若干元素;
  • 笛卡尔积(Cartesian Product):指从多个不同集合(如 A、B、C)中各取一个元素,组合成有序元组 (a, b, c) 的所有可能集合。

根据分步乘法计数原理,组合的总数量等于各集合元素数量的乘积:

$$ \text{总组合数} = |A| \times |B| \times |C| $$

例如:若数组 $A$ 有 40 项,$B$ 有 50 项,$C$ 有 20 项,则可能的结果总数恰好为:

$$ 40 \times 50 \times 20 = 40,000 \text{ 种可能} $$


二、为什么“全量预先塞进内存”是一条歧路?

面对类似需求,最直接的直觉写法往往是“写三层嵌套循环,直接把 4 万个组合结果 push 进一个大数组”:

1
2
3
4
5
6
7
8
9
10
11
12
// ❌ 危险写法:一次性预先计算全量数据并堆积在内存中
function generateAllCombinations(A, B, C) {
const result = [];
for (const a of A) {
for (const b of B) {
for (const c of C) {
result.push([a, b, c]);
}
}
}
return result; // 40,000 个数组实例同时常驻堆内存
}

这种做法在工程落地时存在两个致命问题:

1. 内存压力与 GC 频繁抖动

在 V8 引擎中,每个对象与数组都有固定的头部开销。4 万个三元组数组实例不仅会瞬间占据显著的内存空间,更会引发垃圾回收器(V8 Scavenger / Mark-Sweep)的高频运作。一旦并发量上升,极易造成事件循环卡顿,甚至触发进程 OOM(Out of Memory)异常退出。

2. 灾难性的网络并发

更危险的是后续动作——发送网络请求。如果先实例化包含了 4 万个元素的大数组,很多初学者很容易顺手写出如下代码:

1
2
3
// ❌ 极度危险:瞬间并发 40,000 个 HTTP 请求
const allData = generateAllCombinations(A, B, C);
await Promise.all(allData.map(item => sendRequest(item)));

这样做会在几毫秒内将 40,000 个未决(Pending)的 Promise 和底层 Socket 连接塞进事件循环调度器:

  • 操作系统底层直接报错:Error: connect EMFILE(文件描述符/句柄耗尽);
  • 目标服务器瞬间被高并发打瘫,触发防火墙或限流熔断,返回 429 Too Many Requests 或 502 Bad Gateway;
  • Node.js 进程由于保存海量异步调度的闭包上下文而撑爆内存。

因此,解决问题的根本法则在于:按需惰性生成(Lazy Evaluation) + 受控并发消费(Concurrency Pool)。


三、方案演进一:混合进制计数系统与闭包状态机

数学上,多个数组的笛卡尔积遍历可以严格映射为一个变进制计数系统(Mixed Radix Number System):

  • 假设三个数组 A、B、C;
  • 我们把 C 的下标看作最低位(个位),进制基数为 C.length;
  • 把 B 的下标看作十位,进制基数为 B.length;
  • 把 A 的下标看作最高位(百位),进制基数为 A.length;
  • 每次获取一个元素,最低位指针 Ci 自增 1;当 Ci 满位进位时,Ci 归零,Bi 加 1;同理,Bi 满位进位给 Ai。

通过闭包,我们可以把指针状态封装在内部,每次仅按批次(Chunk)拉取所需数量的数据:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
* 基于变进制计数原理的闭包批处理生成器
* @param {Array} A 百位数据集合
* @param {Array} B 十位数据集合
* @param {Array} C 个位数据集合
* @returns {Function} 接收 batchSize 参数的分批拉取函数
*/
function createBatchCombinations(A, B, C) {
let Ai = 0;
let Bi = 0;
let Ci = 0;

const Al = A.length;
const Bl = B.length;
const Cl = C.length;

return function getBatch(batchSize = 10) {
const list = [];
let count = 0;

// 当最高位超出长度时,代表所有排列组合已遍历完毕
while (count < batchSize && Ai < Al) {
list.push([A[Ai], B[Bi], C[Ci]]);
count++;
Ci++;

// 低位逢基数进位
if (Ci >= Cl) {
Ci = 0;
Bi++;
}
// 中位逢基数进位
if (Bi >= Bl) {
Bi = 0;
Ai++;
}
}

return list;
};
}

// 使用示例:
const A = [1, 2, 0, 23];
const B = [3, 4, 10, 77];
const C = [5, 6, 20, 4];

const nextBatch = createBatchCombinations(A, B, C);

console.log(nextBatch(3)); // 分批拉取前 3 条组合
console.log(nextBatch(3)); // 继续拉取接下来的 3 条组合

方案评价

  • 优势:避免了一次性把 4 万条数据全量常驻在数组中,实现了“随用随取”。
  • 痛点:
    1. 维度硬编码:如果业务数据扩展为 4 维、5 维或不固定的 N 维,手动编写多级进位条件不仅晦涩,而且极易出现边界溢出错误;
    2. 仍需手动管理游标与批次状态。

四、方案演进二:现代语言标准范式 —— ES6 Generator(生成器)

在现代 JavaScript(ES6+)中,这种“按需计算、即用即取”的场景,最规范优雅的语言级解法是 Generator(生成器 function* 与 yield)。

生成器天然支持迭代器协议(Iterator Protocol),支持在执行期间随时挂起并保留上下文,并在外部调用 .next() 时精确恢复执行,空间复杂度恒定为 O(1)。

1. 三维笛卡尔积的基础 Generator 实现

1
2
3
4
5
6
7
8
9
function* cartesianProduct3(A, B, C) {
for (const a of A) {
for (const b of B) {
for (const c of C) {
yield [a, b, c]; // 执行到此挂起,按需产出结果,无多余内存堆积
}
}
}
}

代码仅需数行,逻辑清晰直观,完全交由 JS 引擎管理调用栈与状态转移。

2. 进阶:通用多维(N 维)笛卡尔积生成器

在生产环境中,数据维度通常是动态的。我们可以借助递归回溯与生成器委托(yield*),实现通用的任意 N 维笛卡尔积生成器:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
* 通用 N 维笛卡尔积惰性生成器
* @param {Array<Array>} arrays 二维数组,包含任意多个待组合的一维数组
* @returns {Generator} 逐个产出组合结果
*/
function* cartesianProduct(arrays) {
if (!arrays || arrays.length === 0) return;

function* backtrack(depth, current) {
if (depth === arrays.length) {
yield [...current];
return;
}
for (const item of arrays[depth]) {
current.push(item);
yield* backtrack(depth + 1, current);
current.pop(); // 回溯撤销,状态复用
}
}

yield* backtrack(0, []);
}

// 示例:无论 2 组、3 组还是 5 组数据均可直接传入
const dimensions = [
['北京', '上海', '广州'],
['技术部', '产品部'],
['主管', '专员']
];

for (const combination of cartesianProduct(dimensions)) {
console.log(combination.join(' - '));
}

五、工程落地:海量异步请求的滑动窗口并发池

解决了数据生成阶段的内存占用,接下来解决核心瓶颈——如何安全、高效地发送 4 万次网络请求?

如果全串行(单任务依次执行),总耗时过长;如果全并行(Promise.all),网络瞬间雪崩。

正统解法是:设置一个固定容量的滑动并发窗口(Concurrency Pool),保持当前正在执行的网络请求数量恒定在安全阈值(例如并发 10~15),每当一个请求完成,便从 Generator 中拉取下一个任务补充进流水线,实现真正的背压(Backpressure)流控。

完整并发调度器实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/**
* 模拟网络请求任务
*/
function mockRequest(taskData, id) {
return new Promise((resolve) => {
const cost = Math.floor(Math.random() * 200) + 100; // 模拟 100~300ms 网络延迟
setTimeout(() => {
resolve(`[Task ${id}] 成功完成: ${taskData.join('-')}`);
}, cost);
});
}

/**
* 带有并发池控制的海量任务执行器
* @param {Iterable} generator 惰性数据生成器
* @param {Function} taskFn 实际执行异步操作的函数 (data, index) => Promise
* @param {number} concurrency 最大并发连接数
*/
async function runWithConcurrency(generator, taskFn, concurrency = 10) {
let taskId = 0;
let activeWorkers = 0;
let hasMore = true;

return new Promise((resolve) => {
// 递归调度器:一旦有空闲槽位,立刻从生成器拉取下一个任务
function next() {
// 当生成器耗尽且当前无活跃 Worker 时,全部任务完成
if (!hasMore && activeWorkers === 0) {
return resolve();
}

while (activeWorkers < concurrency && hasMore) {
const { value, done } = generator.next();

if (done) {
hasMore = false;
break;
}

activeWorkers++;
const currentId = ++taskId;

// 执行异步任务
taskFn(value, currentId)
.then((res) => {
// 在此可将结果直接流式写入文件或数据库,避免在内存中缓存结果
// console.log(res);
})
.catch((err) => {
console.error(`Task ${currentId} Failed:`, err);
})
.finally(() => {
activeWorkers--;
next(); // 释放槽位,自动调度补充下一个任务
});
}
}

// 启动初始并发池
next();
});
}

// ---------------- 实战运行 ----------------
async function main() {
const A = Array.from({ length: 40 }, (_, i) => `A${i + 1}`);
const B = Array.from({ length: 50 }, (_, i) => `B${i + 1}`);
const C = Array.from({ length: 20 }, (_, i) => `C${i + 1}`);
// 40 * 50 * 20 = 40,000 种可能

console.log('开始安全流式处理海量任务...');
const startTime = Date.now();

const iterator = cartesianProduct([A, B, C]);

// 最大并发保持 15 个连接,流水线式稳定推进
await runWithConcurrency(iterator, mockRequest, 15);

console.log(`40,000 任务处理完毕,耗时: ${(Date.now() - startTime) / 1000}s`);
}

// main();

六、方案综合对比

考量维度方案一:全量预生成大数组方案二:闭包进制进位方案三:Generator + 并发池(推荐)
内存复杂度O(N)(数万个对象常驻内存)O(Batch)(仅保留当前批次数据)O(1)(极致精简,仅保存调用游标)
垃圾回收压力极重,频繁触发 GC 卡顿较低极轻微,无额外数组堆积
多维扩展性差(需重写多层循环)差(硬编码下标变量)极优(原生支持任意 N 维动态组合)
网络安全性极高风险(易触发连接耗尽)取决于外部调用控制极高(稳定限流,保护双方系统)
代码可维护性普通逻辑晦涩清爽优雅,符合 ES 现代标准

七、总结

回顾最初的问题:“怎么把 4 万条数据放在内存中处理?”

很多看似是“内存溢出”或“单机性能瓶颈”的疑难问题,本质上都是计算时机与数据吞吐模型的问题:

  1. 变“预存全量”为“惰性推导”:数学上这是集合的笛卡尔积,无需在内存中一次性实例化所有结果。利用 Generator 的 yield 特性,可以将空间复杂度从 O(N) 降到 O(1)。
  2. 变“无界并发”为“滑动流控”:海量 I/O 操作必须配套并发池(Concurrency Pool)与背压机制,动态平衡生产与消费速率。

建立起“流式处理(Streaming)”的工程思维后,不论面对的是 4 万条、40 万条还是上千万条数据,在 Node.js 中都能从容应对、稳定运行。


4W 条数据笛卡尔积的内存流式处理
https://bubao.github.io/posts/ad5468c0.html
作者
一念
发布于
2021年8月2日
许可协议