6

我尝试了一个非常小的例子：

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

namespace TPLExample {
    class Program {
        static void Main(string[] args) {
            int[] dataItems = new int[100];
            double[] resultItems = new double[100];

            for (int i = 0; i < dataItems.Length; ++i) {
                dataItems[i] = i;
            }

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Reset();
            stopwatch.Start();
            Parallel.For(0, dataItems.Length, (index) => {
                resultItems[index] = Math.Pow(dataItems[index], 2);
            });
            stopwatch.Stop();
            Console.WriteLine("TPL Time elapsed: {0}", stopwatch.Elapsed);

            stopwatch.Reset();
            stopwatch.Start();
            for (int i = 0; i < dataItems.Length; ++i) {
                resultItems[i] = Math.Pow(dataItems[i], 2);
            }
            stopwatch.Stop();
            Console.WriteLine("Sequential Time elapsed: {0}", stopwatch.Elapsed);

            WaitForEnterKey();
        }

        public static void WaitForEnterKey() {
            Console.WriteLine("Press enter to finish");
            Console.ReadLine();
        }

        public static void PrintMessage() {
            Console.WriteLine("Message printed");
        }
    }
}

输出是：

TPL Time elapsed: 00:00:00.0010670
Sequential Time elapsed: 00:00:00.0000178
Press enter to finish

顺序循环比 TPL 快得多！这怎么可能？据我了解，内部的计算Parallel.For将并行执行，所以它必须更快吗？

4

4 回答 4

10

简而言之：对于仅迭代一百多个项目并执行一个小的数学运算，产生新线程并等待它们完成会产生比运行循环更多的开销。

据我了解，Parallel.For中的计算将并行执行，所以它必须更快吗？

当人们对计算机性能做出全面的陈述时，通常会发生这种情况，这里有更多的变量在起作用，你不能真正做出这样的假设。例如，在您的for循环中，您所做的只是Math.Pow处理器可以非常快速地执行。如果这是一个 I/O 密集型操作，需要每个线程等待很长时间，或者即使它是一系列处理器密集型操作，您将从并行处理中获得更多收益（假设您有一个多线程处理器） . 但事实上，创建和同步这些线程的开销远远大于并行性可能给您带来的任何优势。

于 2012-05-26T02:39:41.013 回答
10

当在循环内执行的操作相对昂贵时，并行循环处理是有益的。您在示例中所做的只是计算指数，这很简单。在这种情况下，多线程的开销远远超过了您获得的收益。

于 2012-05-26T02:41:27.013 回答
2

这个代码示例是上面非常好的答案的实际证明。

我通过 Thead.Sleep 简单地阻塞线程来模拟密集的处理器操作。

输出是：

  • 顺序循环 - 00:00:09.9995500
  • 并行循环 - 00:00:03.0347901

_

class Program
{
    static void Main(string[] args)
    {
        const int a = 10;

        Stopwatch sw = new Stopwatch();
        sw.Start();

        //for (long i = 0; i < a; i++)
        //{
        //    Thread.Sleep(1000);
        //}

        Parallel.For(0, a, i =>
        {
            Thread.Sleep(1000);
        });

        sw.Stop();

        Console.WriteLine(sw.Elapsed);

        Console.ReadLine();
    }
}
于 2012-08-17T12:37:13.760 回答
1

并行化的开销远远大于简单地顺序运行 Math.Pow 100 次。其他人都这么说了。

更重要的是，虽然在顺序版本中内存访问是微不足道的，但在并行版本中，线程必须共享内存（resultItems），即使你有一百万个项目，这种事情也会真正杀死你。

请参阅此出色的Microsoft 并行编程白皮书 的第 44 页：http: //www.microsoft.com/en-us/download/details.aspx?id=19222。这是一篇关于该主题的 MSDN 杂志文章：http: //msdn.microsoft.com/en-us/magazine/cc872851.aspx

于 2012-05-26T03:03:24.887 回答