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时，此测试在我的机器上大约3次失败，实际结果小于预期。当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），以防您想要做它是另一种方式（但我很确定这不是你想要做的）。

建议1：减少线程并行化

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

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

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

线程太多导致结果不正确

2 个答案: