我正在玩 C#，想加快程序的速度。我进行了更改并且能够这样做。但是，我需要帮助来理解为什么更改使其更快。

我试图在一个问题中将代码简化为更容易理解的内容。 Score1 和 Report1 是较慢的方式。 Score2 和 Report2 是更快的方法。第一种方法首先将一个字符串和一个整数并行存储在一个结构中。接下来，在串行循环中，它循环遍历这些结构的数组并将它们的数据写入缓冲区。第二种方法首先将数据并行写入字符串缓冲区。接下来，在串行循环中，它将字符串数据写入缓冲区。以下是一些示例运行时间:

运行 1 总平均时间 = 0.492087 秒 运行 2 总平均时间 = 0.273619 秒

当我使用它的早期非并行版本时，时间几乎相同。为什么与平行版本不同？

即使我减少 Report1 中的循环以将单行输出写入缓冲区，它仍然较慢(总时间约为 0.42 秒)。

这是简化的代码:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.Threading.Tasks;
using System.IO;

namespace OptimizationQuestion
{
    class Program
    {
        struct ValidWord
        { 
            public string word;
            public int score;
        }
        ValidWord[] valid;
        StringBuilder output;
        int total; 

        public void Score1(string[] words)
        {
            valid = new ValidWord[words.Length];

            for (int i = 0; i < words.Length; i++)
            {
                StringBuilder builder = new StringBuilder();

                foreach (char c in words[i])
                {
                    if (c != 'U')
                        builder.Append(c);
                }
                if (words[i].Length == 3)
                {
                    valid[i] = new ValidWord 
                    { word = builder.ToString(), score = words[i].Length };
                }
            }
        }
        public void Report1(StringBuilder outputBuffer)
        {
            int total = 0;
            foreach (ValidWord wordInfo in valid)
            {
                if (wordInfo.score > 0)
                {
                    outputBuffer.AppendLine(String.Format("{0} {1}", wordInfo.word.ToString(), wordInfo.score));
                    total += wordInfo.score;
                }
            }
            outputBuffer.AppendLine(string.Format("Total = {0}", total));
        }

        public void Score2(string[] words)
        {
            output = new StringBuilder();
            total = 0;           
            for (int i = 0; i < words.Length; i++)
            {
                StringBuilder builder = new StringBuilder();

                foreach (char c in words[i])
                {
                    if (c != 'U')
                        builder.Append(c);
                }
                if (words[i].Length == 3)
                {
                    output.AppendLine(String.Format("{0} {1}", builder.ToString(), words[i].Length));
                    total += words[i].Length;
                }
            }
        }
        public void Report2(StringBuilder outputBuffer)
        {
            outputBuffer.Append(output.ToString());
            outputBuffer.AppendLine(string.Format("Total = {0}", total));
        } 
        static void Main(string[] args)
        {
            Program[] program = new Program[100];
            for (int i = 0; i < program.Length; i++)
                program[i] = new Program(); 

            string[] words = File.ReadAllLines("words.txt");

            Stopwatch stopwatch = new Stopwatch();
            const int TIMING_REPETITIONS = 20;
            double averageTime1 = 0.0;
            StringBuilder output = new StringBuilder();
            for (int i = 0; i < TIMING_REPETITIONS; ++i)
            {
                stopwatch.Reset();
                stopwatch.Start();
                output.Clear();
                Parallel.ForEach<Program>(program, p =>
                    {
                        p.Score1(words);
                    });
                for (int k = 0; k < program.Length; k++)
                    program[k].Report1(output);
                stopwatch.Stop();
                averageTime1 += stopwatch.Elapsed.TotalSeconds;
                GC.Collect();
            }
            averageTime1 /= (double)TIMING_REPETITIONS;
            Console.WriteLine(string.Format("Run 1 Total Average Time = {0:0.000000} sec", averageTime1));
            double averageTime2 = 0.0;
            for (int i = 0; i < TIMING_REPETITIONS; ++i)
            {
                stopwatch.Reset();
                stopwatch.Start();
                output.Clear();
                Parallel.ForEach<Program>(program, p =>
                    {
                        p.Score2(words);
                    });
                for (int k = 0; k < program.Length; k++)
                    program[k].Report2(output);
                stopwatch.Stop();
                averageTime2 += stopwatch.Elapsed.TotalSeconds;
                GC.Collect();
            }
            averageTime2 /= (double)TIMING_REPETITIONS;
            Console.WriteLine(string.Format("Run 2 Total Average Time = {0:0.000000} sec", averageTime2));
            Console.ReadLine();
        }
    }
}

最佳答案

首先，您要并行化重复运行。这将改善您的基准测试时间，但可能对您的实际生产运行时间帮助不大。要准确测量实际运行一个单词列表需要多长时间，您需要一次只运行一个单词列表。否则，处理所有列表的各个线程会在某种程度上相互竞争系统资源，并且每个列表的时间会受到影响，即使处理所有列表的总时间更快。

为了加快处理一个单词列表的时间，您希望并行处理列表中的各个单词，一次只处理一个列表。为了获得足够的清晰度/大小以进行良好的测量，要么使列表非常长，要么连续多次处理列表。

在您的情况下，这有点棘手，因为您的最终产品所需的 stringbuilder 未记录为线程安全的。不过，还不错。以下是为单个单词列表调用并行 foreach 的示例:

var locker = new Object(); //I'd actually make this static, but it should end up as a closure and so still work
var OutputBuffer = new StringBuilder(); // you can improve things futher if you can make a good estimate for the final size and force it allocate all the memory it will need up front
int score = 0;
Parallel.ForEach(words, w => 
{
   // We want to push as much of the work to the individual threads as possible.
   // If run in 1 thread, a stringbuilder per word would be bad.
   // Run in parallel, it allows us to do a little more of the work outside of locked code.
   var buf = new StringBuilder(w.Length + 5);
   string word = buf.Append(w.Where(c=>c!='U').Concat(' ').ToArray()).Append(w.Length).ToString();

   lock(locker)
   {
       OutputBuffer.Append(word);
       score += w.Length;
   }
});
OutputBuffer.Append("Total = ").Append(score);

只需在正常顺序处理的 for 循环中调用 20 次即可。同样，它完成基准测试的速度可能会慢一些，但我认为由于基准测试中的缺陷，它在现实世界中的表现会更快一些。另请注意，我是在回复窗口中直接输入的——我从来没有尝试过编译它，所以它不太可能一开始就完美无缺。

在修复基准以更准确地反射(reflect)并行代码将如何影响您的实际处理时间之后，下一步是做一些 profiling 查看您的程序实际将时间花在哪里。这就是您知道需要改进哪些方面的方式。

出于好奇，我也想知道这个版本的性能如何:

var agg = new {score = 0, OutputBuffer = new StringBuilder()};
agg = words.Where(w => w.Length == 3)
   .Select(w => new string(w.Where(c => c!='U').ToArray())
   .Aggregate(agg, (a, w) => {a.OutputBuffer.AppendFormat("{0} {1}\n", w, w.Length); score += w.Length;});
agg.OutputBuffer.Append("Total = ").Append(score);

关于c# - 帮助理解 C# 优化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/4941640/