为何调整并行任务线程数会导致求和结果不一致？（CPU问题延伸）

我来帮你拆解下问题的核心原因，主要有两个关键点导致了线程数变化时结果不一致：

1. int类型溢出引发的计算错误 #

你的temp变量是int类型，而C#里int的取值范围仅为 -2,147,483,648 到 2,147,483,647。当单个任务需要处理数百万甚至上千万个元素时，temp的累加值很容易突破这个范围，触发整数溢出。

默认情况下C#不会对整数溢出抛出异常，而是按照二进制补码规则循环计算（比如超过最大值后会直接绕到最小值区间）。不同的线程数量会让每个任务处理的元素区间不同，溢出发生的时机和结果也不一样，最终导致每个任务返回的temp值失真，总和自然也就不一致了。

举个例子：如果某个任务处理的元素区间里，正数总和减负数总和的实际值是3,000,000,000，这已经远超int的最大值，溢出后会变成一个负数，直接拉低最终的求和结果。

2. 延迟枚举导致的元素分配遗漏 #

你定义的intList是Enumerable.Range(1, 1000_000_000)，这是一个延迟执行的序列——它不会提前生成所有元素，而是在每次枚举时才按需生成。

问题出在这两行代码的逻辑上：

int skip = ((i - 1) * count) / threads;
int take = count / threads;

首先，当count（10亿）不能被threads整除时，count / threads会做整数除法，导致最后一个任务的take值不足以覆盖剩余元素。比如线程数为6时，10亿 / 6 = 166666666，6个任务总共只处理了6 * 166666666 = 999,999,996个元素，直接漏掉了最后4个元素。

其次，因为intList是延迟序列，每个任务在调用list.Skip(skip).Take(take)并枚举时，都会从头开始生成序列并跳过前skip个元素。虽然这不会导致元素重叠，但线程数变化会改变每个任务的处理区间，再结合溢出问题，结果会进一步偏离正确值。

修复方案 #

针对这两个问题，你可以这样修改代码：

方案1：改用长整型避免溢出 #

把temp、返回值以及最终求和的变量都改成long类型，这样就能容纳更大的数值，彻底避免溢出：

private static long SumParallel() {
    var intList = Enumerable.Range(1, 1000_000_000);
    int count = intList.Count();
    int threads = 6;
    List<Task<long>> l = new List<Task<long>>(threads);
    for(int i = 1; i <= threads; i++) {
        int skip = ((i - 1) * count) / threads;
        // 处理最后一个任务的剩余元素，避免遗漏
        int take = i == threads ? count - skip : count / threads;
        l.Add(GetSum(intList, skip, take));
    }
    Task.WaitAll(l.ToArray());
    return l.Sum(t => t.Result);
}

private static Task<long> GetSum(IEnumerable<int> list, int skip, int take) {
    return Task.Run(() => {
        long temp = 0; // 改用long类型存储累加值
        foreach(int n in list.Skip(skip).Take(take)) {
            if (n % 2 == 0) temp -= n;
            else temp += n;
        }
        Console.WriteLine(temp + " " + Task.CurrentId);
        return temp;
    });
}

方案2：提前转为集合提升性能（可选） #

因为Enumerable.Range的Skip在处理大skip值时会很慢（需要从头遍历到目标位置），你可以提前把序列转为数组，让Skip和Take操作更高效：

// 在SumParallel开头添加这行，将延迟序列转为数组
int[] intArray = Enumerable.Range(1, 1000_000_000).ToArray();
// 后续把所有intList的引用换成intArray即可

额外优化：用PLINQ简化并行代码 #

其实你可以直接用PLINQ来实现并行求和，它会自动处理线程分配和元素分区，代码更简洁高效：

private static long SumParallel() {
    return Enumerable.Range(1, 1000_000_000)
        .AsParallel()
        .Sum(n => n % 2 == 0 ? - (long)n : (long)n);
}

这样修改后，不管你调整多少线程数，求和结果都会保持一致，同时性能也会有明显提升。

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