线程过多导致结果不正确

Question

这是一个看似简单的类，用于对数组中的所有元素求和：

class ArraySum
{
    class SumRange
    {
        int left;
        int right;
        int[] arr;
        public int Answer { get; private set; }

        public SumRange(int[] a, int l, int r)
        {
            left = l;
            right = r;
            arr = a;
            Answer = 0;
        }

        public void Run()
        {
            if (right - left == 1)
            {
                Answer = arr[left];
            }
            else
            {
                SumRange leftRange = new SumRange(arr, left, (left + right) / 2);
                SumRange rightRange = new SumRange(arr, (left + right) / 2, right);

                Thread leftThread = new Thread(leftRange.Run);
                Thread rightThread = new Thread(rightRange.Run);
                leftThread.Start();
                rightThread.Start();
                leftThread.Join();
                rightThread.Join();

                Answer = leftRange.Answer + rightRange.Answer;
            }
        }
    }

    public static int Sum(int[] arr)
    {
        SumRange s = new SumRange(arr, 0, arr.Length);
        s.Run();
        return s.Answer;
    }
}

当然，这不是执行此任务的有效方式。这也是线程的非常低效的使用。编写本课程是为了说明一个基本的分而治之的解决方案概念，并且希望能够做到这一点。

这里也是这个类的一个简单的单元测试：

public void should_calculate_array_sum()
{
    int N = 1000;
    int[] arr = System.Linq.Enumerable.Range(0, N).ToArray();

    int sum = ArraySum.Sum(arr);

    Assert.AreEqual(arr.Sum(), sum);
}

这就是问题所在。当 N 设置为 1000 时，此测试在我的机器上失败了大约 5 次（共 5 次），实际结果小于预期。当 N 为 100 及以下时 - 它永远不会失败，或者至少我从未见过它失败。

为什么这个程序会失败？这显然是一种非常低效的方法，线程管理的开销太大，但至少它应该总是正常工作，对吧？要么有一些我看不到的细微错误，要么有一些我不理解的线程概念。

另外，我不是在寻找更好的方法来解决这个特定的问题，也不是在寻找更好的方法来说明相同的概念。我只是想弄清楚为什么这种特殊方法有时会失败。

Answer 1

在将 Run 函数包装在 try-catch 中之后，我将这段代码放入控制台应用程序并运行了几次（参见下面的代码）。有几次，当我看到数字不同时，抛出了许多 OutOfMemory 异常。

因此，它似乎取决于运行时如何以及何时分配线程以及它当时可用的资源。详细地说，如果运行时决定分配线程，然后在没有任何线程完成工作的情况下进入下一个时间片，则可以同时启动并运行所有 2000 多个线程（每个线程都被分配1MB 的堆栈空间，以及其他内存资源）。这将很快耗尽您的 2GB 进程内存分配（所有 Windows 32 位进程都有）。

或者，如果它分配一些线程，让它们完成它们的工作然后死掉，然后分配更多线程，你将不会达到如此高的峰值内存并且会成功完成 - 这完全取决于运行时决定如何安排工作。正如其他人所指出的，使用 ThreadPool 将解决该问题，因为它重用了线程。

public void Run()
{
    try
    {
        if (right - left == 1)
        {
            Answer = arr[left];
        }
        else
        {
            SumRange leftRange = new SumRange(arr, left, (left + right) / 2);
            SumRange rightRange = new SumRange(arr, (left + right) / 2, right);

            Thread leftThread = new Thread(leftRange.Run);
            Thread rightThread = new Thread(rightRange.Run);
            leftThread.Start();
            rightThread.Start();
            leftThread.Join();
            rightThread.Join();

            Answer = leftRange.Answer + rightRange.Answer;
        }
    }
    catch(Exception e)
    {
        Console.WriteLine("Error: " + e.Message);
        Debug.WriteLine("Error: " + e.Message);
    }
}

Answer 2

您没有创建 数百 个线程，甚至 1000 个线程。它可能更像是 2000 个线程。

证明

为了使数学更容易，说 N = 1024。

# bisections  Range  Number of threads
      1       1024     1      (main thread)
      2       512      2
      3       256      4
      4       128      8
      5       64       16
      6       32       32
      7       16       64
      8       8        128
      9       4        256
      10      2        512
      11      1        1024   (individual sum thread)

线程总数 = 1024 + 512 + 256 + ... 4 + 2 + 1 = 2047。显然，并非所有线程都需要同时处于活动状态（当我运行它时，许多线程在计算过程中被杀死），但您肯定创建大约 2000 个线程。

---

我不是在寻找更好的方法来解决这个特定问题，也不是在寻找更好的方法来说明相同的概念。

如果您想（可能）通过微小的更改来解决您的问题，请遵循我的建议 1。我添加了一些其他方法来做到这一点（TPL，ThreadPool），以防您想以另一种方式（但我很确定这不是你想要做的）。

建议一：减少线程并行化

如果您修改使用线程的方式，例如

Thread leftThread = new Thread(leftRange.Run);
leftThread.Start();
leftThread.Join();

Thread rightThread = new Thread(rightRange.Run);
rightThread.Start();
rightThread.Join();

那么任何给定线程一次只会产生 一个 线程，因此 活动 线程的数量最多为 11 个。

建议 2：使用任务并行库

从 .NET Framework 4 开始，TPL 是编写多线程和并行代码的首选方式

Task Parallel Library 可能是您最好的选择，除非您特别想自己处理线程。

下面的内容远未优化 - 按照我在下面的方式使用 TPL 会产生很多开销，但它演示了该方法。

public void Run()
{
    if ( right - left == 1 )
    {
        Answer = arr[left];
    }
    else
    {
        Answer = new bool[] { true, false }
            .AsParallel()
            .Sum(isLeft =>
                {
                    SumRange sumRange = isLeft
                        ? new SumRange(arr, left, (left + right) / 2)
                        : new SumRange(arr, (left + right) / 2, right);
                    sumRange.Run();
                    return sumRange.Answer;
                });
    }
}

当我运行它时，它非常慢，因为它并行运行两个项目。您可能需要考虑分解成更大的组（例如 10 个）而不是一分为二。回到 N = 1000：

# bisections  Range  Number of threads
      1       1000     1      (main thread)
      2       100      10
      3       10       100
      4       1        1000

这将最大线程数减少到1111，但TPL会大大减少。

建议 3：线程池

我认为您可能应该考虑使用ThreadPool 来创建线程 - 这样，线程的最小数量只有 11（即从二等分 1 到二等分 11 的路径）。我不知道如何使用ThreadPool，但这里有一个看起来很有用的链接：MSDN: How to use a Thread Pool。