C#并行编程

C#并行编程中的Parallel.Invoke

一、基础知识

并行编程：并行编程是指软件开发的代码，它能在同一时间执行多个计算任务，提高执行效率和性能一种编程方式，属于多线程编程范畴。所以我们在设计过程中一般会将很多任务划分成若干个互相独立子任务，这些任务不考虑互相的依赖和顺序。这样我们就可以使用很好的使用并行编程。但是我们都知道多核处理器的并行设计使用共享内存，如果没有考虑并发问题，就会有很多异常和达不到我们预期的效果。不过还好NET Framework4.0引入了Task Parallel Library（TPL）实现了基于任务设计而不用处理重复复杂的线程的并行开发框架。它支持数据并行，任务并行与流水线。核心主要是Task，但是一般简单的并行我们可以利用Parallel提供的静态类如下三个方法。

Parallel.Invoke  对给定任务实现并行开发

Parallel.For  对固定数目的任务提供循环迭代并行开发

parallel.Foreach 对固定数目的任务提供循环迭代并行开发

注意：所有的并行开发不是简单的以为只要将For或者Foreach换成Parallel.For与Parallel.Foreach这样简单。

PS：从简单的Invoke开始逐步深入探讨并行开发的主要知识点，也对自己学习过程中的积累做个总结，其中参考了博客园中的其他优秀博文

滴答的雨 异步编程：轻量级线程同步基元对象

首先感谢您，在我学习并行开发过程中，您的博文对我帮助很大。

二、Parallel.Invoke在并行中的使用

首先我们来看看它的两个重载方法：

　　public static void Invoke(params Action[] actions);
　　public static void Invoke(ParallelOptions parallelOptions, params Action[] actions);

Invoke主要接受params的委托actions，比如我们要同时执行三个任务，我们可以这样利用

  方式一
       Parallel.Invoke(() => Task1(), () => Task2(), () => Task3());
  方式二
       Parallel.Invoke(Task1, Task2, Task3);
  方式三
       Parallel.Invoke(
                () =>
                {
                    Task1();
                },
                Task2,
                delegate () { Task3(); console.write('do someting!');});

这样Invoke就简单实现了Task1，Task2，Task3的并行开发。下面我们用实例来说明他们的执行规则。以及两个重载方法的使用。

三 、Demo

1、 Demo 1：

public class ParallelInvoke
    {
        /// <summary>
        /// Invoke方式一 action
        /// </summary>
        public  void Client1()
        {
            Stopwatch stopWatch = new Stopwatch();

            Console.WriteLine("主线程：{0}线程ID ： {1}；开始", "Client1", Thread.CurrentThread.ManagedThreadId);
            stopWatch.Start();
            Parallel.Invoke(() => Task1("task1"), () => Task2("task2"), () => Task3("task3"));
            stopWatch.Stop();
            Console.WriteLine("主线程：{0}线程ID ： {1}；结束,共用时{2}ms", "Client1", Thread.CurrentThread.ManagedThreadId, stopWatch.ElapsedMilliseconds);
        }

        private void Task1(string data)
        {
            Thread.Sleep(5000);
            Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
        }

        private void Task2(string data)
        {
            Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
        }

        private void Task3(string data)
        {
            Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
        }
｝

执行运行后结果：

aaarticlea/png;base64,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" alt="" />

我们看到Invoke 执行Task三个方法主要有以下几个特点：

1、没有固定的顺序，每个Task可能是不同的线程去执行，也可能是相同的；

2、主线程必须等Invoke中的所有方法执行完成后返回才继续向下执行；这样对我们以后设计并行的时候，要考虑每个Task任务尽可能差不多，如果相差很大，比如一个时间非常长，其他都比较短，这样一个线程可能会影响整个任务的性能。这点非常重要

3、这个非常简单就实现了并行，不用我们考虑线程问题。主要Framework已经为我们控制好线程池的问题。

ps：如果其中有一个异常怎么办？ 带做这个问题修改了增加了一个Task4.

2、 Demo2

    public class ParallelInvoke
    {
        /// <summary>
        /// Invoke方式一 action
        /// </summary>
        public  void Client1()
        {
            Stopwatch stopWatch = new Stopwatch();

            Console.WriteLine("主线程：{0}线程ID ： {1}；开始", "Client1", Thread.CurrentThread.ManagedThreadId);
            stopWatch.Start();

            try
            {
                Parallel.Invoke(() => Task1("task1"), () => Task2("task2"), () => Task3("task3"), delegate () { throw new Exception("我这里发送了异常"); });
            }
            catch (AggregateException ae)
            {
                foreach (var ex in ae.InnerExceptions)
                    Console.WriteLine(ex.Message);
            }

            stopWatch.Stop();
            Console.WriteLine("主线程：{0}线程ID ： {1}；结束,共用时{2}ms", "Client1", Thread.CurrentThread.ManagedThreadId, stopWatch.ElapsedMilliseconds);
        }
   ｝

主要看 delegate() { throw new Exception("我这里发送了异常");} 增加了这个委托Task3. 然后我们看结果：

aaarticlea/png;base64,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" alt="" />

这里我们发现即使有异常程序也会完成执行，而且不会影响其他Task的执行。

3、demo3 重载方法ParallelOptions 的使用。

理解ParallelOptions建议大家异步编程：轻量级线程同步基元对象讲的非常详细。

主要理解两个参数：

CancellationToken     控制线程的取消
     MaxDegreeOfParallelism  设置最大的线程数，有时候可能会跑遍所有的内核，为了提高其他应用程序的稳定性，就要限制参与的内核

下面从代码上看效果如何？

 public class ParallelInvoke
    {
 　　　　// 定义CancellationTokenSource 控制取消
        readonly CancellationTokenSource _cts = new CancellationTokenSource();

        /// <summary>
        /// Invoke方式一 action
        /// </summary>
        public  void Client1()
        {
             Console.WriteLine("主线程：{0}线程ID ： {1}；开始{2}", "Client3", Thread.CurrentThread.ManagedThreadId, DateTime.Now);

            var po = new ParallelOptions
            {
                CancellationToken = _cts.Token, // 控制线程取消
                MaxDegreeOfParallelism = 3  // 设置最大的线程数3，仔细观察线程ID变化
            };

            Parallel.Invoke(po, () => Task1("task1"), ()=>Task5(po), Task6);

            Console.WriteLine("主线程：{0}线程ID ： {1}；结束{2}", "Client3", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
        }

        private void Task1(string data)
        {
            Thread.Sleep(5000);
            Console.WriteLine("任务名：{0}线程ID ： {1}", data, Thread.CurrentThread.ManagedThreadId);
        }

        // 打印数字
        private void Task5(ParallelOptions po)
        {
            Console.WriteLine("进入Task5线程ID ： {0}", Thread.CurrentThread.ManagedThreadId);
            int i = 0;
          while (i < 100)
            {
                // 判断是否已经取消
                if (po.CancellationToken.IsCancellationRequested)
                {
                    Console.WriteLine("已经被取消。");
                    return;
                }

                Thread.Sleep(100);
                Console.Write(i + " ");
                Interlocked.Increment(ref i);
            }

        }

        /// <summary>
        /// 10秒后取消
        /// </summary>
        private void Task6()
        {
            Console.WriteLine("进入取消任务，Task6线程ID ： {0}", Thread.CurrentThread.ManagedThreadId);
            Thread.Sleep(1000 * 10);
            _cts.Cancel();
            Console.WriteLine("发起取消请求...........");
        }
｝    

执行结果：

aaarticlea/png;base64,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" alt="" />

从程序结果我们看到以下特点：

1、程序在执行过程中线程数码不超过3个。

2、CancellationTokenSource/CancellationToken控制任务的取消。

四、总结

Parallel.Invoke 的使用过程中我们要注意以下特点：

1、没有特定的顺序，Invoke中的方法全部执行完才返回，但是即使有异常在执行过程中也同样会完成，他只是一个很简单的并行处理方法，特点就是简单，不需要我们考虑线程的问题。

2、如果在设计Invoke中有个需要很长时间，这样会影响整个Invoke的效率和性能，这个我们在设计每个task时候必须去考虑的。

3、Invoke 参数是委托方法。

4、当然Invoke在每次调用都有开销的，不一定并行一定比串行好，要根据实际情况，内核环境多次测试调优才可以。

5、异常处理比较复杂。