JavaScript中变量超2^32致内存耗尽的解决方案咨询

错误含义解释 #

你遇到的Mark-sweep ... allocation failure; scavenge might not succeed是V8引擎（Node.js/Chrome使用的JS引擎）的垃圾回收报错，意思是内存占用已接近设备上限，GC的标记-清除阶段无法回收足够空间分配新内存，最终导致内存耗尽。

内存耗尽的根本原因 #

不是mod的位宽问题——JS的数字本身是64位双精度浮点数，能精确表示远大于2^32的数值。真正的问题是数组元素指数级增长：
每次迭代中，r、coef、cons数组的长度大概率翻倍（多数分支会给每个现有元素生成2个新元素）。当迭代33次时，最坏情况下数组长度会达到2^33（约8.5亿），三个这样的数组会占用十几GB内存，远超普通设备的可用内存上限。

可行的优化方案 #

1. 数学推导替代数组存储（最优解） #

无需维护所有r、coef、cons元素，通过分析规律直接计算total：
观察代码逻辑，每次迭代的操作具有规律性，可以将每组(r, coef, cons)抽象为状态，推导状态的变换公式，甚至合并重复状态，避免存储海量元素。

比如，初始状态是r=1, coef=3, cons=1, mod=2，每次迭代后：

• 若(coef*r + cons) % mod !== 0：新状态的coef=3*原coef，cons=3*原cons + mod/2，r的范围可以用区间[原r, 原r+mod)代替单个值（因为r和r+mod在后续mod*2的模运算中等价）
• 若(coef*r + cons) % mod === 0且coef < mod：直接累加1/mod到total，无需生成新状态
• 若(coef*r + cons) % mod === 0且coef >= mod：状态的coef和cons不变，r的范围扩展为[原r, 原r+2*mod)

基于这个逻辑，用状态对象存储区间和系数的优化代码如下：

function runOptimized(vals, count) {
    let total = 0.5;
    let { r: initialR, coef: initialCoef, cons: initialCons, mod } = { ...vals };
    // 用状态数组存储：{ rStart, rEnd, coef, cons }，rEnd = rStart + 区间长度
    let states = [{ rStart: initialR, rEnd: initialR + 1, coef: initialCoef, cons: initialCons }];

    const startTime = performance.now();

    for (let j = 0; j < count; j++) {
        const newStates = [];
        const currentMod = mod;

        for (const state of states) {
            const { rStart, rEnd, coef, cons } = state;
            // 计算区间内r对应的模结果规律
            const base = (coef * rStart + cons) % currentMod;
            const step = (coef % currentMod + currentMod) % currentMod; // 确保步长非负

            if (step === 0) {
                // 所有r的模结果都是base
                if (base === 0) {
                    if (coef >= currentMod) {
                        // 扩展r的范围，保留原状态
                        newStates.push({
                            rStart,
                            rEnd: rEnd + currentMod,
                            coef,
                            cons
                        });
                    } else {
                        // 累加区间内元素数量 * 1/currentMod
                        total += (rEnd - rStart) / currentMod;
                    }
                } else {
                    // 所有r都不满足模0，生成新状态
                    newStates.push({
                        rStart,
                        rEnd: rEnd + currentMod,
                        coef: 3 * coef,
                        cons: 3 * cons + currentMod / 2
                    });
                }
            } else {
                // 计算区间内模0的元素数量
                const cycleLength = currentMod / gcd(step, currentMod);
                const offset = (currentMod - base) % currentMod;
                const firstZero = offset === 0 ? rStart : rStart + Math.ceil(offset / step);
                let zeroCount = 0;

                if (firstZero < rEnd) {
                    zeroCount = Math.floor((rEnd - firstZero - 1) / cycleLength) + 1;
                }

                // 处理模0的情况
                if (coef < currentMod) {
                    total += zeroCount / currentMod;
                } else {
                    newStates.push({
                        rStart: firstZero,
                        rEnd: firstZero + zeroCount * cycleLength,
                        coef,
                        cons
                    });
                }

                // 处理非模0的情况
                const nonZeroLength = (rEnd - rStart) - zeroCount;
                if (nonZeroLength > 0) {
                    newStates.push({
                        rStart,
                        rEnd: rStart + nonZeroLength,
                        coef: 3 * coef,
                        cons: 3 * cons + currentMod / 2
                    });
                }
            }
        }

        states = newStates;
        mod *= 2;
    }

    const endTime = performance.now();
    const executionTime = endTime - startTime;

    return { total: total * 100, executionTime: executionTime.toFixed(2) };
}

// 辅助函数：计算最大公约数
function gcd(a, b) {
    while (b !== 0) {
        [a, b] = [b, a % b];
    }
    return a;
}

const initialVals = {
    r: 1,
    coef: 3,
    cons: 1,
    mod: 2,
};

const iterations = 33;
const result = runOptimized(initialVals, iterations);
console.log(`Iterations: ${iterations}, Total: ${result.total}%, Execution Time: ${result.executionTime}ms`);

2. 控制数组增长（次优解） #

如果暂时无法推导数学规律，可以在每次迭代后清理不必要的状态，或者合并重复状态（比如相同coef和cons的r可以合并为区间），避免数组长度指数级膨胀。

关于mod位宽的说明 #

JS的数字类型是64位双精度浮点数，能精确表示的整数范围是-2^53到2^53，远大于2^32，所以不需要提升mod的内存位宽——内存耗尽的核心是数组元素过多，而非mod数值大小。

内容的提问来源于stack exchange，提问作者Anonymous