【转】【C#】【Thread】【Parallel】并行计算

时间 2019-11-11

原文原文链接

并行计算

沿用微软的写法，System.Threading.Tasks.Parallel类，提供对并行循环和区域的支持。咱们会用到的方法有For，ForEach，Invoke。html

Program.Data = new List<int>();
for (int i = 0; i < 10; i++)
{
      Data.Add(i);
}

下面咱们定义4个方法，分别为for，foreach，并行For，并行ForEach。并测试他们的运行时长。算法

        /// <summary>
        /// 是否显示执行过程
        /// </summary>
        public bool ShowProcessExecution = false;
        /// <summary>
        /// 这是普通循环for
        /// </summary>
        private void Demo1()
        {
            List<int> data = Program.Data;
            DateTime dt1 = DateTime.Now;
            for (int i = 0; i < data.Count; i++)
            {
                Thread.Sleep(500);
                if (ShowProcessExecution)
                    Console.WriteLine(data[i]);
            }
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("普通循环For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
        }
        /// <summary>
        /// 这是普通循环foreach
        /// </summary>
        private void Demo2()
        {
            List<int> data = Program.Data;
            DateTime dt1 = DateTime.Now;
            foreach (var i in data)
            {
                Thread.Sleep(500);
                if (ShowProcessExecution)
                    Console.WriteLine(i);
            }
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("普通循环For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
        }
        /// <summary>
        /// 这是并行计算For
        /// </summary>
        private void Demo3()
        {
            List<int> data = Program.Data;
            DateTime dt1 = DateTime.Now;
            Parallel.For(0, data.Count, (i) =>
            {
                Thread.Sleep(500);
                if (ShowProcessExecution)
                    Console.WriteLine(data[i]);
            });
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("并行运算For运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
        }
        /// <summary>
        /// 这是并行计算ForEach
        /// </summary>
        private void Demo4()
        {
            List<int> data = Program.Data;
            DateTime dt1 = DateTime.Now;
            Parallel.ForEach(data, (i) =>
            {
                Thread.Sleep(500);
                if (ShowProcessExecution)
                    Console.WriteLine(i);
            });
            DateTime dt2 = DateTime.Now;
            Console.WriteLine("并行运算ForEach运行时长：{0}毫秒。", (dt2 - dt1).TotalMilliseconds);
        }

下面是运行结果：数组

这里咱们能够看出并行循环在执行效率上的优点了。安全

结论1：在对一个数组内的每个项作单独处理时，彻底能够选择并行循环的方式来提高执行效率。多线程

原理1：并行计算的线程开启是缓步开启的，线程数量1,2,4,8缓步提高。（不详，PLinq最多64个线程，可能这也是64）函数

2、并行循环的中断和跳出

当在进行循环时，偶尔会须要中断循环或跳出循环。下面是两种跳出循环的方法Stop和Break，LoopState是循环状态的参数。oop

        /// <summary>
        /// 中断Stop
        /// </summary>
        private void Demo5()
        {
            List<int> data = Program.Data;
            Parallel.For(0, data.Count, (i, LoopState) =>
            {
                if (data[i] > 5)
                    LoopState.Stop();
                Thread.Sleep(500);
                Console.WriteLine(data[i]);
            });
            Console.WriteLine("Stop执行结束。");
        }
        /// <summary>
        /// 中断Break
        /// </summary>
        private void Demo6()
        {
            List<int> data = Program.Data;
            Parallel.ForEach(data, (i, LoopState) =>
            {
                if (i > 5)
                    LoopState.Break();
                Thread.Sleep(500);
                Console.WriteLine(i);
            });
            Console.WriteLine("Break执行结束。");
        }

执行结果以下：测试

结论2：使用Stop会当即中止循环，使用Break会执行完毕全部符合条件的项。spa

3、并行循环中为数组/集合添加项

上面的应用场景其实并非很是多见，毕竟只是为了遍历一个数组内的资源，咱们更多的时候是为了遍历资源，找到咱们所须要的。那么请继续看。线程

下面是咱们通常会想到的写法：

        private void Demo7()
        {
            List<int> data = new List<int>();
            Parallel.For(0, Program.Data.Count, (i) =>
            {
                if (Program.Data[i] % 2 == 0)
                    data.Add(Program.Data[i]);
            });
            Console.WriteLine("执行完成For.");
        }
        private void Demo8()
        {
            List<int> data = new List<int>();
            Parallel.ForEach(Program.Data, (i) =>
            {
                if (Program.Data[i] % 2 == 0)
                    data.Add(Program.Data[i]);
            });
            Console.WriteLine("执行完成ForEach.");
        }

看起来应该是没有问题的，可是咱们屡次运行后会发现，偶尔会出现错误以下：

这是由于List是非线程安全的类，咱们须要使用System.Collections.Concurrent命名空间下的类型来用于并行循环体内。

类	说明
BlockingCollection<T>	为实现 IProducerConsumerCollection<T> 的线程安全集合提供阻止和限制功能。
ConcurrentBag<T>	表示对象的线程安全的无序集合。
ConcurrentDictionary<TKey, TValue>	表示可由多个线程同时访问的键值对的线程安全集合。
ConcurrentQueue<T>	表示线程安全的先进先出 (FIFO) 集合。
ConcurrentStack<T>	表示线程安全的后进先出 (LIFO) 集合。
OrderablePartitioner<TSource>	表示将一个可排序数据源拆分红多个分区的特定方式。
Partitioner	提供针对数组、列表和可枚举项的常见分区策略。
Partitioner<TSource>	表示将一个数据源拆分红多个分区的特定方式。

那么咱们上面的代码能够修改成，加了了ConcurrentQueue和ConcurrentStack的最基本的操做。

        /// <summary>
        /// 并行循环操做集合类,集合内只取5个对象
        /// </summary>
        private void Demo7()
        {
            ConcurrentQueue<int> data = new ConcurrentQueue<int>();
            Parallel.For(0, Program.Data.Count, (i) =>
            {
                if (Program.Data[i] % 2 == 0)
                    data.Enqueue(Program.Data[i]);//将对象加入到队列末尾
            });
            int R;
            while (data.TryDequeue(out R))//返回队列中开始处的对象
            {
                Console.WriteLine(R);
            }
            Console.WriteLine("执行完成For.");
        }
        /// <summary>
        /// 并行循环操做集合类
        /// </summary>
        private void Demo8()
        {
            ConcurrentStack<int> data = new ConcurrentStack<int>();
            Parallel.ForEach(Program.Data, (i) =>
            {
                if (Program.Data[i] % 2 == 0)
                    data.Push(Program.Data[i]);//将对象压入栈中
            });
            int R;
            while (data.TryPop(out R))//弹出栈顶对象
            {
                Console.WriteLine(R);
            }
            Console.WriteLine("执行完成ForEach.");
        }

ok，这里返回一个序列的问题也解决了。

结论3:在并行循环内重复操做的对象，必需要是thread-safe(线程安全)的。集合类的线程安全对象所有在System.Collections.Concurrent命名空间下。

4、返回集合运算结果/含有局部变量的并行循环

使用循环的时候常常也会用到迭代，那么在并行循环中叫作含有局部变量的循环。下面的代码中详细的解释。

        /// <summary>
        /// 具备线程局部变量的For循环
        /// </summary>
        private void Demo9()
        {
            List<int> data = Program.Data;
            long total = 0;
            //这里定义返回值为long类型方便下面各个参数的解释
            Parallel.For<long>(0,           // For循环的起点
                data.Count,                 // For循环的终点
                () => 0,                    // 初始化局部变量的方法(long)，既为下面的subtotal的初值
                (i, LoopState, subtotal) => // 为每一个迭代调用一次的委托，i是当前索引，LoopState是循环状态，subtotal为局部变量名
                {
                    subtotal += data[i];    // 修改局部变量
                    return subtotal;        // 传递参数给下一个迭代
                },
                (finalResult) => Interlocked.Add(ref total, finalResult) //对每一个线程结果执行的最后操做，这里是将全部的结果相加
                );
            Console.WriteLine(total);
        }
        /// <summary>
        /// 具备线程局部变量的ForEach循环
        /// </summary>
        private void Demo10()
        {
            List<int> data = Program.Data;
            long total = 0;
            Parallel.ForEach<int, long>(data, // 要循环的集合对象
                () => 0,                      // 初始化局部变量的方法(long)，既为下面的subtotal的初值
                (i, LoopState, subtotal) =>   // 为每一个迭代调用一次的委托，i是当前元素，LoopState是循环状态，subtotal为局部变量名
                {
                    subtotal += i;            // 修改局部变量
                    return subtotal;          // 传递参数给下一个迭代
                },
                (finalResult) => Interlocked.Add(ref total, finalResult) //对每一个线程结果执行的最后操做，这里是将全部的结果相加
                );
            Console.WriteLine(total);
        }

结论4:并行循环中的迭代，确实很伤人。代码太难理解了。

5、PLinq（Linq的并行计算）

上面介绍完了For和ForEach的并行计算盛宴，微软也没忘记在Linq中加入并行计算。下面介绍Linq中的并行计算。

4.0中在System.Linq命名空间下加入了下面几个新的类：

类	说明
ParallelEnumerable	提供一组用于查询实现 ParallelQuery{TSource} 的对象的方法。这是 Enumerable 的并行等效项。
ParallelQuery	表示并行序列。
ParallelQuery<TSource>	表示并行序列。

原理2：PLinq最多会开启64个线程

原理3：PLinq会本身判断是否能够进行并行计算，若是不行则会以顺序模式运行。

原理4：PLinq会在昂贵的并行算法或成本较低的顺序算法之间进行选择，默认状况下它选择顺序算法。

在ParallelEnumerable中提供的并行化的方法

ParallelEnumerable 运算符	说明
AsParallel()	PLINQ 的入口点。指定若是可能，应并行化查询的其他部分。
AsSequential()	指定查询的其他部分应像非并行 LINQ 查询同样按顺序运行。
AsOrdered()	指定 PLINQ 应保留查询的其他部分的源序列排序，直到例如经过使用 orderby 子句更改排序为止。
AsUnordered()	指定查询的其他部分的 PLINQ 不须要保留源序列的排序。
WithCancellation()	指定 PLINQ 应按期监视请求取消时提供的取消标记和取消执行的状态。
WithDegreeOfParallelism()	指定 PLINQ 应当用来并行化查询的处理器的最大数目。
WithMergeOptions()	提供有关 PLINQ 应当如何（若是可能）将并行结果合并回到使用线程上的一个序列的提示。
WithExecutionMode()	指定 PLINQ 应当如何并行化查询（即便默认行为是按顺序运行查询）。
ForAll()	多线程枚举方法，与循环访问查询结果不一样，它容许在不首先合并回到使用者线程的状况下并行处理结果。
Aggregate() 重载	对于 PLINQ 惟一的重载，它启用对线程本地分区的中间聚合以及一个用于合并全部分区结果的最终聚合函数。

下面是PLinq的简单代码

        /// <summary>
        /// PLinq简介
        /// </summary>
        private void Demo11()
        {
            var source = Enumerable.Range(1, 10000);
            //查询结果按source中的顺序排序
            var evenNums = from num in source.AsParallel().AsOrdered()
                       where num % 2 == 0
                       select num;
            //ForAll的使用
            ConcurrentBag<int> concurrentBag = new ConcurrentBag<int>();
            var query = from num in source.AsParallel()
                        where num % 10 == 0
                        select num;
            query.ForAll((e) => concurrentBag.Add(e * e));
        }

上面代码中使用了ForAll，ForAll和foreach的区别以下：

PLinq的东西很繁杂，可是都只是几个简单的方法，熟悉下方法就行了。