平行运算:Parallel.For、Parallel.Foreach的体验式试用[通俗易懂]

平行运算:Parallel.For、Parallel.Foreach的体验式试用[通俗易懂]在编程里面我们经常会遇到编历一个列表或数组做同一件事情或操作,当这个数组或列表很大时又或是需要进行很复杂的操作时,就会花费很长的时间。以前我就在想能不能在这种情况下使用多线程的方式提高效率,可惜一直都没机会和动力(实际需要)去研究。今天在网上查找资料,很偶然的发现.NETFramework4.0中平行算法相关内容(Parallel.For、Parallel.Foreach),原来.NET已经实

大家好,又见面了,我是你们的朋友全栈君。

       在编程里面我们经常会遇到编历一个列表或数组做同一件事情或操作,当这个数组或列表很大时又或是需要进行很复杂的操作时,就会花费很长的时间。以前我就在想能不能在这种情况下使用多线程的方式提高效率,可惜一直都没机会和动力(实际需要)去研究。今天在网上查找资料,很偶然的发现.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));
        }

测试结果

平行运算:Parallel.For、Parallel.Foreach的体验式试用[通俗易懂]

测试分析结果: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的体验式试用[通俗易懂]

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

平行运算:Parallel.For、Parallel.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的使用应该要特别小心,它们的优势是处理列表很长,且对列表内的元素进行很复杂的业务逻辑,且不会使用共享资源,只针对自身的业务逻辑处理,方才能提升效率。因为如果逻辑过于简单的话,创建线程的花费将大于业务执行的花费,得不偿失。

参考资料

平行运算 (一):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

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

发布者:全栈程序员-用户IM,转载请注明出处:https://javaforall.cn/161833.html原文链接:https://javaforall.cn

【正版授权,激活自己账号】: Jetbrains全家桶Ide使用,1年售后保障,每天仅需1毛

【官方授权 正版激活】: 官方授权 正版激活 支持Jetbrains家族下所有IDE 使用个人JB账号...

(0)
blank

相关推荐

  • snmptrap使用[通俗易懂]

    snmptrap使用[通俗易懂]SNMP简单网络管理协议,其中其支持的一个命令snmptrap命令,用于模拟向管理机发送trap消息。启动陷阱方法:snmptrapd-C-c/etc/snmp/snmptrapd.conf-Lf/var/log/net-snmptrap.log例如:snmptrap-v1-cpublic192.168.2.124.1.3.6.1.4.1…

  • 基于单片机的八路抢答器设计论文_抢答器的程序流程图

    基于单片机的八路抢答器设计论文_抢答器的程序流程图文末下载完整资料1.1八路扫描式抢答器的概述  本文介绍的八路数显抢答器具有电路简单、成本较低、操作方便、灵敏可靠等优点,经使用效果良好,具有较高的推广价值。无线遥控抢答器,它由8个发射器和1个接收器组成,可用于8组或8组以下的智力竞赛中。比赛前,将参赛组从0至7编号,每组发给对应的一个发射器。将接收器放于各组中央或前方。主持人按一下启动键后,抢答开始。此后,哪一组最先按下发射器上的抢答键,接收器就立即显示该组的组号并锁定,同时发出3次清脆的“叮咚”声。以后,按下任何一路抢答键均不起反映。只有主

    2022年10月20日
  • nginx 基础命令

    nginx 基础命令nginx 基础命令

  • python电脑版微信-微信PC版的API接口 | 可通过Python调用微信功能

    python电脑版微信-微信PC版的API接口 | 可通过Python调用微信功能微信PC版的API接口,可通过Python调用微信获取好友、群、公众号列表,并收发消息,接受转账、好友请求、入群请求,群管理等功能。可用于二次开发在线微信机器人、微信消息监控、群控软件、开发界面作多个微信控制软件等用途。clone/下载源码到本地安装源码包里的微信客户端(你以前的版本和这个不一致的都需要安装这个)执行源码中的test.py目前提供pyd和依赖的相关文件,通过python直接impo…

  • 跳频介绍_跳频功能

    跳频介绍_跳频功能跳频是最常用的扩频方式之一,其工作原理是指收发双方传输信号的载波频率按照预定规律进行离散变化的通信方式,也就是说,通信中使用的载波频率受伪随机变化码的控制而随机跳变。从通信技术的实现方式来说,“跳频”是一种用码序列进行多频频移键控的通信方式,也是一种码控载频跳变的通信系统。从时域上来看,跳频信号是一个多频率的频移键控信号;从频域上来看,跳频信号的频谱是一个在很宽频带上以不等间隔随机跳变的。其中:跳

    2022年10月23日
  • window计算机日志分析详解,windows系统日志分析

    window计算机日志分析详解,windows系统日志分析一、Windows日志文件的保护日志文件对我们如此重要,因此不能忽视对它的保护,防止发生某些“不法之徒”将日志文件清洗一空的情况。1.修改日志文件存放目录Windows日志文件默认路径是“%systemroot%system32config”,我们可以通过修改注册表来改变它的存储目录,来增强对日志的保护。点击“开始→运行”,在对话框中输入“Regedit”,回车后弹出注册表编辑器,依次展开“HK…

发表回复

您的电子邮箱地址不会被公开。

关注全栈程序员社区公众号