最近有项目对于性能要求非常高，虽然系统大部分都是IO密集型，但也不排除有计算密集型的操作，比如将来在项目中采用了Mongdb，那么将会有非常多的机会对大的泛型集合进行查询，计算(比如sum操作)等，多少能起到一定的性能提升作用,多核心CPU如果不充分利用起来实在有些可惜。
    
     文中的部分代码均参考Parallel Programming with Microsoft .NET，这篇文章是以第五章后面的习题来分享。题目给了一个思路，对于一个过程是否可以采取并行运算，最好事先画一张流程图，看看哪些部分是可以并行的，即之间没有任何的依赖关系,图中能放在一个水平线上的即表示可以并行的部分。

                                                                    
     说明：

         1:本文的代码不考虑IO，即全部代码都是在CPU中执行,对于有IO的情况，会在后面的文章中做充分的尝试。
         2:测试环境是:Intel(R) Core(TM)2 Duo CPU T9550 @2.66GHZ

     题目：将下面代码并行起来。
     var b = F1(a);  var d = F2(c);  var e = F3(b,d);  var f = F4(e);  var g = F5(e); var h = F6(f,g);
    
     首先我们来看下这6个函数的执行流程图，图中箭头代表依赖方向，线上的字母分别代表输入输出参数。
                                                                
     分析：从图中可以看出，F1,F2在同一水平线了，同样，F4,F5也在同一水平线上，这说明这两部分是可以并行的。
    
     测试的核心函数是一个数字累加的过程：

View Code

/// <summary>
        /// Simulates a CPU-intensive operation on a single core. The operation will use approximately 100% of a
        /// single CPU for a specified duration.
        /// </summary>
        /// <param name="seconds">The approximate duration of the operation in seconds</param>
        /// <returns>true if operation completed normally; false if the user canceled the operation</returns>
        public static bool DoCpuIntensiveOperation(double seconds)
        {
            return DoCpuIntensiveOperation(seconds, CancellationToken.None, false);
        }

        /// <summary>
        /// Simulates a CPU-intensive operation on a single core. The operation will use approximately 100% of a
        /// single CPU for a specified duration.
        /// </summary>
        /// <param name="seconds">The approximate duration of the operation in seconds</param>
        /// <param name="token">A token that may signal a request to cancel the operation.</param>
        /// <param name="throwOnCancel">true if an execption should be thrown in response to a cancellation request.</param>
        /// <returns>true if operation completed normally; false if the user canceled the operation</returns>
        public static bool DoCpuIntensiveOperation(double seconds, CancellationToken token, bool throwOnCancel = false)
        {
            if (token.IsCancellationRequested)
            {
                if (throwOnCancel)
                    token.ThrowIfCancellationRequested();
                return false;
            }

            long ms = (long)(seconds * 1000);
            Stopwatch sw = new Stopwatch();
            sw.Start();
            long checkInterval = Math.Min(20000000, (long)(20000000 * seconds));

            // loop to simulate a computationally intensive operation
            int i = 0;
            while (true)
            {
                i += 1;

                // periodically check to see if the user has requested cancellation 
                // or if the time limit has passed
                if (seconds == 0.0d || i % checkInterval == 0)
                {
                    if (token.IsCancellationRequested)
                    {
                        if (throwOnCancel) token.ThrowIfCancellationRequested();
                        return false;
                    }

                    if (sw.ElapsedMilliseconds > ms)
                        return true;
                }
            }
        }

     6个函数内容如下，基本就是些加减法：

View Code

/// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F1(int value)
        {
            SampleUtilities.DoCpuIntensiveOperation(2.0);
            return value * value;
        }

        /// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F2(int value)
        {
            SampleUtilities.DoCpuIntensiveOperation(1.0);
            return value - 2;
        }
        /// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F3(int value1, int value2)
        {
            SampleUtilities.DoCpuIntensiveOperation(0.1);
            return value1 + value2;
        }
        /// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F4(int value)
        {
            SampleUtilities.DoCpuIntensiveOperation(1.0);
            return value + 1;
        }

       
        /// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F5(int value)
        {
            SampleUtilities.DoCpuIntensiveOperation(1.0);
            return value + 5;
        }
        /// <summary>
        /// A computationally intensive function
        /// </summary>
        static int F6(int value1, int value2)
        {
            SampleUtilities.DoCpuIntensiveOperation(1);
            return value1 + value2;
        }

     为了做对比，我分别做了以下几部分测试：
     1:传统的顺序计算；  
     2:只将F1并行起来；
     3:只将F4并行起来；
     4:将F1,F4都并行起来。
      

        
        测试结果:从下图可以非常清晰的看出，在使用并行后，性能得到了明显的提升，如果在release下应该效果会更好。

       下面的一个测试，只是写法上的不同，从理论上来讲，和Example4对比没有实质的性能提升。如果两个任务可以并行，我们将其中一个task用并行模式即可。
         

      执行的测试结果图如下：

    总结：并行运算是个好东西，主要是需要搞清楚它的适用场景，它主要针对计算型的运算，如果都是些数据库操作之类的IO访问，作用并不是特别大，如果处理的数据量不大，性能也不会有提升，反而也许会有影响，创建线程也是需要开销的，核心的就是确认好适用场景，然后是确认可以并行的部分。对于IO操作，下面的内容我会根据实际情况做些测试，本文有什么不对的地方，希望大家批评指正。

作者: 姜敏 发表于 2011-07-31 21:24 原文链接