在 C# 中使用多线程加速循环（问题）

Question

想象一下，我有一个函数可以遍历一百万/十亿个字符串并检查其中的内容。

f.ex：

foreach (String item in ListOfStrings)
{
    result.add(CalculateSmth(item));
}

它消耗大量时间，因为CalculateSmth是非常耗时的函数。

我想问：如何在这种过程中集成多线程？

f.ex：我想启动 5 个线程，每个线程都会返回一些结果，这样一直持续下去，直到列表中有项目为止。

也许任何人都可以展示一些示例或文章..

忘记提及我在 .NET 2.0 中需要它

Answer 1

您可以尝试并行扩展（.NET 4.0的一部分）

这些允许你可以这样写：

Parallel.Foreach (ListOfStrings, (item) => 
    result.add(CalculateSmth(item));
);

当然 result.add 需要是线程安全的。

Answer 2

并行扩展很酷，但这也可以通过使用线程池来完成，如下所示：

using System.Collections.Generic;
using System.Threading;

namespace noocyte.Threading
{
    class CalcState
    {
        public CalcState(ManualResetEvent reset, string input) {
            Reset = reset;
            Input = input;
        }
        public ManualResetEvent Reset { get; private set; }
        public string Input { get; set; }
    }

    class CalculateMT
    {
        List<string> result = new List<string>();
        List<ManualResetEvent> events = new List<ManualResetEvent>();

        private void Calc() {
            List<string> aList = new List<string>();
            aList.Add("test");

            foreach (var item in aList)
            {
                CalcState cs = new CalcState(new ManualResetEvent(false), item);
                events.Add(cs.Reset);
                ThreadPool.QueueUserWorkItem(new WaitCallback(Calculate), cs);
            }
            WaitHandle.WaitAll(events.ToArray());
        }

        private void Calculate(object s)
        {
            CalcState cs = s as CalcState;
            cs.Reset.Set();
            result.Add(cs.Input);
        }
    }
}

Answer 3

请注意，并发并不会神奇地为您提供更多资源。 您需要确定是什么导致CalculateSmth 变慢。

例如，如果它受 CPU 限制（并且您使用的是单核），则无论您是顺序执行还是并行执行，代码都会获得相同数量的 CPU 时钟周期。 另外，您还会从管理线程中获得一些开销。 相同的参数适用于其他约束（例如 I/O），

如果CalculateSmth 在其执行期间保持资源空闲（可以由另一个实例使用），您将仅获得性能提升。 这并不罕见。 例如，如果任务涉及 IO，然后是一些 CPU 内容，则进程 1 可能正在执行 CPU 内容，而进程 2 正在执行 IO。 正如马茨指出的，如果有基础设施，生产者-消费者单元链可以实现这一目标。

Answer 4

您需要并行地分解您想要完成的工作。 以下是如何将工作一分为二的示例：

List<string> work = (some list with lots of strings)

// Split the work in two
List<string> odd = new List<string>();
List<string> even = new List<string>();
for (int i = 0; i < work.Count; i++)
{
    if (i % 2 == 0)
    {
        even.Add(work[i]);
    }
    else
    {
        odd.Add(work[i]);
    }
}

// Set up to worker delegates
List<Foo> oddResult = new List<Foo>();
Action oddWork = delegate { foreach (string item in odd) oddResult.Add(CalculateSmth(item)); };

List<Foo> evenResult = new List<Foo>();
Action evenWork = delegate { foreach (string item in even) evenResult.Add(CalculateSmth(item)); };

// Run two delegates asynchronously
IAsyncResult evenHandle = evenWork.BeginInvoke(null, null);
IAsyncResult oddHandle = oddWork.BeginInvoke(null, null);

// Wait for both to finish
evenWork.EndInvoke(evenHandle);
oddWork.EndInvoke(oddHandle);

// Merge the results from the two jobs
List<Foo> allResults = new List<Foo>();
allResults.AddRange(oddResult);
allResults.AddRange(evenResult);

return allResults;

Answer 5

你必须回答的第一个问题是你是否应该使用线程

如果你的函数CalculateSmth()基本上是CPU限制的，即CPU使用率很高并且基本上没有I/O使用率，那么我很难理解这一点使用线程，因为线程将竞争相同的资源，在本例中是 CPU。

如果您的CalculateSmth()同时使用CPU和I/O，那么使用线程可能是一个要点。

我完全同意对我的答案的评论。 我错误地假设我们谈论的是单核 CPU，但现在我们有了多核 CPU，这是我的错。

Answer 6

并不是说我现在这里有任何好的文章，但您想要做的是使用线程池进行生产者-消费者的一些操作。

生产者循环并创建任务（在本例中可能只是将列表或堆栈中的项目排队）。 比如说，消费者是五个线程，它们从堆栈中读取一项，通过计算来消费它，然后将其存储在其他地方。

这样，多线程就仅限于这五个线程，并且它们都将有工作要做，直到堆栈为空。

需要考虑的事情：

• 对输入和输出列表进行保护，例如互斥锁。
• 如果顺序很重要，请确保保持输出顺序。 一个例子是将它们存储在 SortedList 或类似的东西中。
• 确保CalculateSmth是线程安全的，它不使用任何全局状态。