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


相关推荐

  • 说一下 runnable 和 callable 有什么区别(call你)

    Runnable和Callable的区别是,(1)Callable规定的方法是call(),Runnable规定的方法是run().(2)Callable的任务执行后可返回值,而Runnable的任务是不能返回值得(3)call方法可以抛出异常,run方法不可以(4)运行Callable任务可以拿到一个Future对象,Future表示异步计算的结果。它提供了检查计算是否完成的方法,以等待计算的…

  • 在C#中利用wmi操作DNS服务器

    在C#中利用wmi操作DNS服务器public class DNSAdminLib    {        //要连接的DNS服务器        private string sServerPath;        //用户名        private string username = null;        //密码        private string password = null;        //服务器

  • 架构 Roadmap 笔记分享 (2015 年)

    架构 Roadmap 笔记分享 (2015 年)

    2021年11月24日
  • Windows 进程 Tasklist查看 与 Taskkill结束

    Windows 进程 Tasklist查看 与 Taskkill结束目录Tasklist简述使用格式查看本机所有进程根据pid查询指定进程查看远程所有进程Taskkill简述根据进程PID结束根据进程图像名结束/f强制结束进程/t结束进程树Tasklist简述1、”Tasklist”命令是一个用来显示运行在本地或远程计算机上的所有进程的命令行工具,带有多个执行参数。类似Linux系统的ps命令2、显示…

  • MPLS 虚拟专用网络 Hub and Spoke实验

    MPLS 虚拟专用网络 Hub and Spoke实验

  • 【已解决】MySQL Connector Net 卸载不了问题?

    【已解决】MySQL Connector Net 卸载不了问题?今天mysql出现了一些问题,想要全部卸载重新安装,控制面板中右键卸载,发现MySQLConnectorNet无法卸载。百度上搜索发现回答都是复制粘贴,千篇一律,都是检查C盘文件是否删除干净,还有就是注册表是否删除干净;使用这些方法均不能完成卸载,重装mysql。不断搜索发现一方法可行进行分享:1.微软的支持里面有一个Fixproblemsthatblockprogramsfrombeinginstalledorremoved,链接https://support.micros

发表回复

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

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