平行运算：Parallel.For、Parallel.Foreach的体验式试用

最新推荐文章于 2024-07-26 11:00:19 发布
最新推荐文章于 2024-07-26 11:00:19 发布
阅读量3k 收藏 6
点赞数 1
分类专栏： .NET4.0应用技巧 文章标签： parallel 测试 random .net collections string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyx1132/article/details/7035267
版权


       在编程里面我们经常会遇到编历一个列表或数组做同一件事情或操作，当这个数组或列表很大时又或是需要进行很复杂的操作时，就会花费很长的时间。以前我就在想能不能在这种情况下使用多线程的方式提高效率，可惜一直都没机会和动力（实际需要）去研究。今天在网上查找资料，很偶然的发现.NET Framework 4.0中平行算法相关内容（Parallel.For、Parallel.Foreach），原来.NET已经实现这项功能而且语法简化的异常简单。具体内容请大家查阅参考资料，下面将贴出我的测试结果与大家共享。

PS：首先确认开发环境（VS2010+.NET Framework 4）

第一轮测试：

        static void Main(string[] args)
        {
            //产生测试资料
            List<int> testData = new List<int>();
            Random Rand = new Random();
            //产生乱数列表
            for (int i = 0; i < 2147400; i++)
            {
                testData.Add(Rand.Next(1000));
            }
            //打印正确结果
            Console.WriteLine(testData.Sum());

            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine();
                TestFor(testData);
                TestParallelFor(testData);
                TestParallelForeach(testData);
            }
            Console.ReadKey();
        }

        static void TestFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            //记录结果用
            long resultData = 0;
            foreach (var item in testData)
            {
                resultData += item;
            }
            Console.WriteLine(string.Format("ForEach:     \t\t{0} in {1}", resultData, (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            //记录结果用
            long resultData = 0;
            Parallel.For(0, testData.Count , (i, loopState) =>
            {
                resultData += testData[i];
            });
            Console.WriteLine(string.Format("Parallel.For:   \t{0} in {1}", resultData, (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelForeach(List<int> testData)
        {
            //记录结果用
            DateTime time1 = DateTime.Now;
            long resultData = 0;
            Parallel.ForEach(testData, (item, loopState) =>
            {
                resultData += item;
            });
            Console.WriteLine(string.Format("Parallel.ForEach:\t{0} in {1}", resultData, (DateTime.Now - time1).TotalMilliseconds));
        }

测试结果



测试分析结果：Foreach胜出，且Parallel.For、Parallel.Foreach计算均以错误告终，顿时让我失望不已。不过仔细一想，发现应该是平行运算时，因为是多线程同时使用resultData这个共享资源时的访问起了冲突，所以导致最后的求和失败。要想防止资源不起冲突，只能对共享资源进行加锁，但这又与平行算法的思想违背。于是乎改进方法重新测试。

第二轮测试：

        static void Main(string[] args)
        {
            //产生测试资料
            List<int> testData = new List<int>();
            Random Rand = new Random();
            //产生乱数列表
            for (int i = 0; i < 2147401; i++)
            {
                testData.Add(Rand.Next(1000));
            }
            //打印正确结果
            Console.WriteLine(testData.Sum());

            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine();
                TestFor(testData);
                TestParallelFor(testData);
                TestParallelForeach(testData);
            }
            Console.ReadKey();
        }

        static void TestFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            //记录结果用
            List<int> resultData = new List<int>();
            foreach (var item in testData)
            {
                resultData.Add(item);
            }
            Console.WriteLine(string.Format("ForEach:     \t\t{0} in {1}", resultData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            //记录结果用
            ConcurrentStack<int> resultData = new ConcurrentStack<int>();
            Parallel.For(0, testData.Count, (i, loopState) =>
            {
                resultData.Push(testData[i]);
            });
            Console.WriteLine(string.Format("Parallel.For:   \t{0} in {1}", resultData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelForeach(List<int> testData)
        {
            //记录结果用
            DateTime time1 = DateTime.Now;
            ConcurrentStack<int> resultData = new ConcurrentStack<int>();
            Parallel.ForEach(testData, (item, loopState) =>
            {
                resultData.Push(item);
            });
            Console.WriteLine(string.Format("Parallel.ForEach:\t{0} in {1}", resultData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

测试结果



测试分析结果：Parallel.For、Parallel.Foreach计算终于正确，这表明确实是资源访问的问题，但这个效率问题，还不如直接使用Foreach，这是怎么会事儿啊，没道理啊，怎么着我的电脑也还是个双核嘛。


再仔细分析一下，第一轮测试与第二轮的测试结果，虽然第一轮测试Parallel.For、Parallel.Foreach计算错误，但好歹执行效率上与Foreach相差不大，那么效率应该是出在了ConcurrentStack.Push上了。（这是因为在 .Net 3.5 之前所提供的所有 Collections 都不是线程安全的，必須使用.Net 4.0 ， System.Collections.Concurrent Namespace 下的泛型）于是有了以下的第三轮测试~~~~


第三轮测试：

        static void Main(string[] args)
        {
            //产生测试资料
            List<int> testData = new List<int>();
            Random Rand = new Random();
            //产生乱数列表
            for (int i = 0; i < 2147401; i++)
            {
                testData.Add(Rand.Next(1000));
            }
            //打印正确结果
            Console.WriteLine(testData.Sum());

            for (int i = 0; i < 10; i++)
            {
                Console.WriteLine();
                TestFor(testData);
                TestParallelFor(testData);
                TestParallelForeach(testData);
            }
            Console.ReadKey();
        }

        static void TestFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            foreach (var item in testData)
            {
                item.ToString();
            }
            Console.WriteLine(string.Format("ForEach:     \t\t{0} in {1}", testData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelFor(List<int> testData)
        {
            DateTime time1 = DateTime.Now;
            Parallel.For(0, testData.Count, (i, loopState) =>
            {
                testData[i].ToString();
            });
            Console.WriteLine(string.Format("Parallel.For:   \t{0} in {1}", testData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

        static void TestParallelForeach(List<int> testData)
        {
            //记录结果用
            DateTime time1 = DateTime.Now;
            ConcurrentStack<int> resultData = new ConcurrentStack<int>();
            Parallel.ForEach(testData, (item, loopState) =>
            {
                item.ToString();
            });
            Console.WriteLine(string.Format("Parallel.ForEach:\t{0} in {1}", testData.Sum(), (DateTime.Now - time1).TotalMilliseconds));
        }

测试结果



测试分析结果：这下子Parallel.For、Parallel.Foreach终于发挥出了平行运算的优势，将效率提高了接近一半左右。


测试总结：对于Parallel.For、Parallel.Foreach的使用应该要特别小心，它们的优势是处理列表很长，且对列表内的元素进行很复杂的业务逻辑，且不会使用共享资源，只针对自身的业务逻辑处理，方才能提升效率。因为如果逻辑过于简单的话，创建线程的花费将大于业务执行的花费，得不偿失。


参考资料

平行运算 (一)：Parallel.For、Parallel.Foreach 用法及技巧

How to: Write a Simple Parallel.For Loop

How to: Write a Simple Parallel.ForEach Loop

Introducing ConcurrentStack < T >

System.Collections.Concurrent Namespace

The Parallel Programming Of .NET Framework 4.0(1) – Beginning

The Parallel Programming Of .NET Framework 4.0(2) - Task Library

The Parallel Programming Of .NET Framework 4.0(3) - Deep Into Task Library

The Parallel Programming Of .NET Framework 4.0(4) - Inside Out Of Task Library

The Parallel Programming Of .NET Framework 4.0(5) - Dive to Parallel Programming

wyx1132
关注
专栏目录
AI系统Spark原理与代码实战案例讲解
程序员光剑
06-28 399
AI系统Spark原理与代码实战案例讲解 作者：禅与计算机程序设计艺术 / Zen and the Art of Computer Programming 关键词：Apache Spark, 分布式并行计算, 大数据处理, 机器学习加速, 数据流处理, 资源管理, 可移植性
.Net(C#) Parallel.For和Parallel.Invoke介绍及使用方法
weixin_52026996的博客
06-11 97
本文主要介绍.Net(C#)中Parallel.For和Parallel.Invoke相关介绍，及使用方法示例代码。
parallel for-开源
05-03
数据并行科学编程模型。 有效地编译到不同的平台，例如分布式内存（MPI），共享内存多处理器（pthread），Cell BE处理器，Nvidia Cuda，SIMD矢量化（SSE，Altivec）和顺序C ++代码。
C# 多线程Paralle使用
最新发布
qq_44967213的博客
07-26 700
在C#中，Parallel类是 System.Threading.Tasks 命名空间下的一个静态类，它提供了并行执行循环和操作的简便方法。通过使用Parallel类，可以简化多线程编程，提高应用程序执行并行任务的能力。Parallel类主要用于并行执行for和foreach循环。Parallel类包含几个静态方法，如等，这些方法能够自动将迭代分配给多个线程，以实现并行执行。
Parallel.For
weixin_33913332的博客
04-08 171
  Parallel.For方法并行的执行for循环，它又多个重载。最常用的就是 For(Int32, Int32, Action&lt;Int32&gt;) 本人测试了一个求和方法，分别用传统的for语句和Parallel.For，结果发现，for语句不仅计算正确，而且速度比并行更快。而Parallel.For计算机结果还是不正确的。 这是由于Parallel.For在计算...
C# 并行任务——Parallel类
weixin_34015566的博客
06-13 851
一、Parallel类 Parallel类提供了数据和任务的并行性； 二、Paraller.For() Paraller.For()方法类似于C#的for循环语句，也是多次执行一个任务。使用Paraller.For()方法，可以并行运行迭代，迭代的顺序没有定义。 在For()方法中，前两个参数是固定的，这两个参数定义了循环的开头和结束。首先描述它的第一个...
Parallel.For 详解
weixin_34387284的博客
02-01 545
Parallel.For(0, 20, () => { // invoked once for each thread // 对每个线程只初化一次 Console.WriteLine("i...
Java中高级面试题总览(一)
热门推荐
击水三千里的专栏
03-29 2万+
高频面试题深入剖析
前端犄角旮旯，非常规面试题总结（不断更新....）
qq_51398495的博客
06-24 936
27、判断类型的方式有哪些？1、typeof操作符：用来检测数据的类型，返回的是一个表示类型的字符串。2、instanceof操作符：用来检测对象是否为指定的构造函数的实例。3、方法：可以返回对象的准确类型。4、方法：用来判断一个变量是否为数组。（一）typeof和instanceof区别typeof返回的是一个字符串，表示变量的数据类型，可能的返回值有numberstringbooleanfunctionundefinedobject。instanceof返回的是一个布尔值，true或。
java求两个人的平均年龄_Java8 Stream实例--统计出所有含‘张’字的人员的平均年龄...
weixin_36149997的博客
02-25 920
package com.zhangxueliang.demo;import java.util.ArrayList;import java.util.List;import java.util.stream.Stream;public class Lambda_Stream_Demo {public static void main(String[] args){//method1();List ...
如何：编写 parallel_for 循环.doc
09-01
2019 08 licese
2022年Java 工程师面试题
weixin_42572320的博客
03-03 2520
第 1 页 共 485 页 目录 1、什么是 Mybatis？............................................................................... 33 2、Mybaits 的优点：............................................................................... 33 3、MyBatis 框架的缺点：.............................
Parallel的使用 之Parallel.for
xulong5000的专栏
04-03 2097
Paraller.For()方法类似于C#的for循环语句，也是多次执行一个任务。使用Paraller.For()方法，可以并行运行迭代，迭代的顺序没有定义。 在For()方法中，前两个参数是固定的， 这两个参数定义了循环的开头和结束。首先描述它的第一个方法For(int,int,Action<int>)，前面两个参数代表循环的开头和介绍，第三个参数是个委托，整数参数是...
C# Parallel.For 的使用
daijianzhou的专栏
12-11 9712
Parallel.For是微软提供的一个简单的并行计算的方法，这篇文章主要有两个目的 其一，介绍一下Parallel.For的使用 其二，和串行进行比较 1.现在来看看不访问相同资源时，Parallel.For和串行的效率如何，以下是代码 using System; using System.Threading.Tasks; namespace AppCode { class ...
多线程那点事—Parallel.for
子时已过的博客
01-02 646
先看段代码： for (int i = 0; i < 10; i++) { Task.Factory.StartNew(()=>Console.WriteLine($"{Thread.CurrentThread.ManagedThreadId} ~ {i}")); } 从代码上可以看出我们预期是打印1~10，但实际的打印结果是： 7 ~ 10 4 ~ 10 10 ~ 10 9 ~ 10 4 ~ 10 3 ~ 10 5 ~ 10 9 ~ 10 6 ~ 10 8 ~ 10 与预期的不一
Parallel.For循环 和 Parallel.ForEach循环
zxf347085420的博客
07-01 4874
大多时候，我们的循环结构的每一次迭代 依赖于上一次迭代的计算或行为。 但是，有的时候又不是这样。如果迭代之间彼此独立，并且程序运行在多核处理器的机器上，如果能将不同的迭代放在不同的处理器上并行处理的话，将会受益匪浅。Parallel.For 和 Parallel.ForEach结构就是这样做的。 一、Parallel.For 1、Parallel.For方法有12个重载： public s...
C#【多线程篇】Parallel.For和for的效率比较（Paralle.Foreach和foreach比较类似）
lyh79925300的博客
10-18 571
C#【多线程篇】Parallel.For和for的效率比较（Paralle.Foreach和foreach比较类似）
java parallel.for作用_“Parallel.For”for Java？
weixin_35819860的博客
03-06 186
我想最接近的事情是：ExecutorService exec = Executors.newFixedThreadPool(SOME_NUM_OF_THREADS);try {for (final Object o : list) {exec.submit(new Runnable() {@Overridepublic void run() {// do stuff with o.}});}} f...
Parallel.For 和Parallel.ForEach 例子
09-06
### 回答1： Parallel.For 和 Parallel.ForEach 是 C# 中 System.Threading.Tasks 命名空间中的并行循环运算符。 Parallel.For 用于并行循环迭代固定数量的迭代次数。例如： ``` Parallel.For(0, 10, i => { Console.WriteLine("Iteration {0}", i); }); ``` Parallel.ForEach 用于并行循环迭代集合中的元素。例如： ``` List<string> words = new List<string> { "apple", "banana", "cherry" }; Parallel.ForEach(words, word => { Console.WriteLine("Word: {0}", word); }); ``` 这两种运算符都会在多个线程中并行运行，可以帮助提高程序的运行效率。 ### 回答2： Parallel.For和Parallel.ForEach是.NET Framework提供的用于并行处理迭代操作的两个方法。 首先，我们来看一下Parallel.For的例子。假设我们有一个包含100个数字的数组，我们想对每个数字进行平方操作，并在控制台输出。我们可以使用Parallel.For来实现并行化的迭代处理。代码如下： ``` int[] numbers = Enumerable.Range(1, 100).ToArray(); Parallel.For(0, numbers.Length, i => { numbers[i] = numbers[i] * numbers[i]; Console.WriteLine(numbers[i]); }); ``` 在这个例子中，我们使用Enumerable.Range方法创建了一个包含1到100的数组。然后，我们使用Parallel.For方法并行遍历数组中的每个元素。对于每个元素，我们将其平方，并在控制台输出结果。 接下来，我们来看一下Parallel.ForEach的例子。假设我们有一个字符串列表，我们想要并行地将每个字符串转换为大写，并将结果存储在新的列表中。我们可以使用Parallel.ForEach来实现并行化的迭代处理。代码如下： ``` List<string> strings = new List<string> { "hello", "world", "parallel", "foreach" }; List<string> upperCaseStrings = new List<string>(); Parallel.ForEach(strings, str => { upperCaseStrings.Add(str.ToUpper()); }); foreach (string str in upperCaseStrings) { Console.WriteLine(str); } ``` 在这个例子中，我们创建了一个包含几个字符串的列表。然后，我们使用Parallel.ForEach方法并行地遍历列表中的每个字符串。对于每个字符串，我们将其转换为大写，并将结果添加到一个新的列表中。最后，我们使用普通的foreach循环，在控制台输出转换为大写的字符串。 总结起来，Parallel.For和Parallel.ForEach是.NET Framework提供的用于并行处理迭代操作的两个方法。它们可以帮助我们以更高效的方式处理大规模的迭代任务，并发挥多核处理器的优势。 ### 回答3： Parallel.For 是 .NET Framework 中的一个多线程并行编程的方法，它允许我们以一种简单的方式创建一个 for 循环并在多个线程中并行执行循环中的迭代。 下面是一个使用 Parallel.For 方法的示例代码： ``` Parallel.For(0, 10, i => { Console.WriteLine("当前线程ID：{0}，i的值为：{1}", Thread.CurrentThread.ManagedThreadId, i); }); ``` 上述代码会创建一个从0到9的循环，并使用多个线程并行地执行循环中的每个迭代。在控制台输出中，可以看到当前线程的ID和迭代的值。 而 Parallel.ForEach 方法也是 .NET Framework 中的一个多线程并行编程的方法，它允许我们以一种简单的方式遍历一个集合并在多个线程中并行执行每个元素的操作。 下面是一个使用 Parallel.ForEach 方法的示例代码： ``` List<int> numbers = new List<int> { 1, 2, 3, 4, 5 }; Parallel.ForEach(numbers, number => { Console.WriteLine("当前线程ID：{0}，number的值为：{1}", Thread.CurrentThread.ManagedThreadId, number); }); ``` 上述代码会创建一个包含整数的 List 集合，并使用多个线程并行地执行每个元素的操作。在控制台输出中，可以看到当前线程的ID和每个元素的值。 总结来说，Parallel.For 和 Parallel.ForEach 提供了一种简单的方式在多个线程中并行执行循环或集合的操作。通过使用这些方法，我们可以更好地利用多核处理器和多线程编程，从而实现更高效的并行计算。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值