Parallel World 3 – Parallel Loop (1)

在这一系列文章中，我们将会经常用到下面的这些代码， 这些代码中有计算立方和与平方和的代码，没有什么具体意义，只是为了演示并行运算。

class Program
    {
        private const int NUM_MAX = 100000000;

        private static void CubicSum()
        {
            double sum = 0;
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < NUM_MAX; i++)
            {
                sum = sum + Math.Pow((i * (i + 1) / 2), 2);
            }

            Console.WriteLine("CubicSum Excuation Time: {0}",sw.Elapsed.ToString());
            //Console.WriteLine("Cubic Result: {0}", sum);
            //Debug.WriteLine(sw.Elapsed.ToString());
        }

        private static void QuadraticSum()
        {
            double sum = 0;
            var sw = Stopwatch.StartNew();
            for (int i = 0; i < NUM_MAX; i++)
            {
                sum = sum + (2 * i + 1) * (i + 1) * i / 6;
            }

            Console.WriteLine("QuadraticSum Excuation Time: {0}", sw.Elapsed.ToString());
            //Console.WriteLine("Quadratic Result: {0}", sum);
            //Debug.WriteLine(sw.Elapsed.ToString());
        }

        static void Main(string[] args)
        {
            var swSequence = Stopwatch.StartNew();
            QuadraticSum();
            CubicSum();
            //Debug.WriteLine(swSequence.Elapsed.ToString());
            Console.WriteLine("Sequence Excuation Time: {0}", swSequence.Elapsed.ToString());

            Console.WriteLine("--------------------------------------------------");

            var swParallel = Stopwatch.StartNew();
            Parallel.Invoke(() => QuadraticSum(), () => CubicSum());
            Console.WriteLine("Parallel Excuation Time: {0}", swParallel.Elapsed.ToString());
            //Debug.WriteLine(swParallel.Elapsed.ToString());

            Console.WriteLine("Main method finish!");
            Console.ReadLine();
        }
    }

在System.Threading.Tasks.Parallel里提供了以下一些静态方法；我们可以通过下面的这些方法实现并行运算:

I. Parallel.Invoke

并行运行多个方法最简单的方法就是使用这个方法，注意这些方法最好是独立的。先看看并行执行的优势，执行上面的代码，你会看到如下的结果：

第一次看到并行对于性能的提高是不是有些兴奋，不要着急在后续章节中，我们会深入到CPU的每个核中去看看，并且也会讲一下分析并行运算的性能问题。

对于Parallel.Invoke方法有两个重载，第一个接受一个System.Action的数组

第二个增加了一个ParallelOptions (这个我们将在后续章节中讲解)

 

可以用以下几种方式来使用Invoke

       1. 就像它的定义那样，定义一个Action数组，然后传递进去

Action[] actionArray = new Action[3];
actionArray[0] = new Action(() => Console.WriteLine("Action 0"));
actionArray[1] = new Action(() => Console.WriteLine("Action 1"));
actionArray[2] = new Action(() => Console.WriteLine("Action 2"));

Parallel.Invoke(actionArray);

2. 直接把方法名做为参数，逐一传递进去

static void Main(string[] args)
{
    Parallel.Invoke(Method1, Method2, Method3);

    Console.WriteLine("Main method finish!");
    Console.ReadLine();
}

static void Method1()
{
    Console.WriteLine("Method 1");
}

static void Method2()
{
    Console.WriteLine("Method 2");
}

static void Method3()
{
    Console.WriteLine("Method 3");
}

3. 当然你可以使用Lambda表达式、匿名函数和匿名委托

static void Main(string[] args)
{
    Parallel.Invoke(
        () => { Console.WriteLine("Method 1"); },
        () => { Console.WriteLine("Method 2"); },
        delegate() { Console.WriteLine("Method 3"); }
        );

    Console.WriteLine("Main method finish!");
    Console.ReadLine();
}

Invoke的缺点：

1. 使用Invoke时，它所调用的方法是以一种不确定的先后顺序执行的，大家可以多次尝试上述代码，看看执行效果就知道了。因此对于一些比较复杂的并行算法，比如一些需要一个执行计划来控制并发方法的并行算法，简单的Invoke就不适用。

2. 当它所调用的方法之间，运行时间差异很大的时候，它会运行所需的时间将会大于等于运行时间最长的那个方法所需的时间。因此导致CPU中的一些核长时间处于空闲状态。

3. 因为它始终调用固定数量的方法，因此在一个多核的环境中，它可能仅仅使用其中的某几个核，而导致其他核处于空闲状态，比如把上述代码放到一个8核或者更多核的环境中，其中的几个核就会处于空闲状态。

4. 如果它调用的方法之间，存在相互依赖，就会引起很难查找的并发问题，比如在开篇中提到的死锁；当然这个问题不仅仅是Invoke才会存在的问题。

5. 如果在Invoke中抛出Exception，比通常的顺序执行抛出的异常要复杂一些, 所有调用的方法抛出的异常都会被打包放在一个System.AggregateException中，关于这一点我们会在后续文章中讲解到。

Invoke的优点：

1. 使用起来简单，不用担心那些Tasks或者Threads的问题。