AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

.NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（二）

2016-04-25 1508
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介：

引言

随着CPU多核的普及，编程时充分利用这个特性越显重要。上篇首先用传统的嵌套循环进行数组填充，然后用.NET 4.0中的System.Threading.Tasks提供的Parallel Class来并行地进行填充，最后对比他们的性能。本文将深入分析Parallel Class并借机回答上篇9楼提出的问题，而System.Threading.Tasks分析，这个将推迟到.NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（三）中介绍。内容如下：

  • 1、Parallel Class
    • 1.1、For方法
    • 1.2、ForEach方法
    • 1.3、Invoke方法
  • 2、并发控制疑问？
    • 2.1、使用Lock锁
    • 2.2、使用PLINQ——用AsParallel
    • 2.3、使用PLINQ——用ParallelEnumerable
    • 2.4、使用Interlocked操作
    • 2.5、使用Parallel.For的有Thread-Local变量重载函数
  • 性能比较

1、Parallel Class

Parallel——这个类提供对通常操作（诸如for、foreach、执行语句块）基于库的数据并行替换。它只是System.Threading.Tasks命名空间的一个类，该命名空间中还包括很多其他的类。下面举个例子来说明如何使用Parallel.For（来自MSDN）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System.Threading.Tasks;  
class Test
{
     static int N = 1000;
 
     static void TestMethod()
     {
         // Using a named method.
         Parallel.For(0, N, Method2);
 
         // Using an anonymous method.
         Parallel.For(0, N, delegate ( int i)
         {
             // Do Work.
         });
 
         // Using a lambda expression.
         Parallel.For(0, N, i =>
         {
             // Do Work.
         });
     }
 
     static void Method2( int i)
     {
         // Do work.
     }
}

上面这个例子简单易懂，上篇我们就是用的Parallel.For,这里就不解释了。其实Parallel类的方法主要分为下面三类：

  • For方法
  • ForEach方法
  • Invoke方法

1.1、For方法

在里面执行的for循环可能并行地运行，它有12个重载。这12个重载中Int32参数和Int64参数的方法各为6个，下面以Int32为例列出：

下面代码演示了For(Int32 fromInclusive, Int32 toExclusive, ParallelOptions parallelOptions, Action<Int32> body)方法（来自MSDN）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         // Demonstrated features:
         //        CancellationTokenSource
         //         Parallel.For()
         //        ParallelOptions
         //        ParallelLoopResult
         // Expected results:
         //         An iteration for each argument value (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) is executed.
         //        The order of execution of the iterations is undefined.
         //        The iteration when i=2 cancels the loop.
         //        Some iterations may bail out or not start at all; because they are temporally executed in unpredictable order,
         //          it is impossible to say which will start/complete and which won't.
         //        At the end, an OperationCancelledException is surfaced.
         // Documentation:
         //        http://msdn.microsoft.com/en-us/library/system.threading.cancellationtokensource(VS.100).aspx
 
         static void Main( string [] args)
         {
             CancellationTokenSource cancellationSource = new CancellationTokenSource();
             ParallelOptions options = new ParallelOptions();
             options.CancellationToken = cancellationSource.Token;
             try
             {
                 ParallelLoopResult loopResult = Parallel.For(
                     0,
                     10,
                     options,
                     (i, loopState) =>
                     {
                         Console.WriteLine( "Start Thread={0}, i={1}" , Thread.CurrentThread.ManagedThreadId, i);
 
                         // Simulate a cancellation of the loop when i=2
                         if (i == 2)
                         {
                             cancellationSource.Cancel();
                         }
 
                         // Simulates a long execution
                         for ( int j = 0; j < 10; j++)
                         {
                             Thread.Sleep(1 * 200);
 
                             // check to see whether or not to continue
                             if (loopState.ShouldExitCurrentIteration) return ;
                         }
 
                         Console.WriteLine( "Finish Thread={0}, i={1}" , Thread.CurrentThread.ManagedThreadId, i);
                     }
                 );
                 if (loopResult.IsCompleted)
                 {
                     Console.WriteLine( "All iterations completed successfully. THIS WAS NOT EXPECTED." );
                 }
             }
                 // No exception is expected in this example, but if one is still thrown from a task,
                 // it will be wrapped in AggregateException and propagated to the main thread.
             catch (AggregateException e)
             {
                 Console.WriteLine( "Parallel.For has thrown an AggregateException. THIS WAS NOT EXPECTED.\n{0}" , e);
             }
                 // Catching the cancellation exception
             catch (OperationCanceledException e)
             {
                 Console.WriteLine( "An iteration has triggered a cancellation. THIS WAS EXPECTED.\n{0}" , e.ToString());
             }
         }
     }
}

1.2、ForEach方法

在迭代中执行的foreach操作可能并行地执行，它有20个重载。这个方法太多，但用法大概跟For方法差不多，请自行参考MSDN。

1.3、Invoke方法

提供的每个动作可能并行地执行，它有2个重载。

例如下面代码执行了三个操作（来自MSDN）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main()
         {
             try
             {
                 Parallel.Invoke(
                     BasicAction,    // Param #0 - static method
                     () =>            // Param #1 - lambda expression
                     {
                         Console.WriteLine( "Method=beta, Thread={0}" , Thread.CurrentThread.ManagedThreadId);
                     },
                     delegate ()        // Param #2 - in-line delegate
                     {
                         Console.WriteLine( "Method=gamma, Thread={0}" , Thread.CurrentThread.ManagedThreadId);
                     }
                 );
             }
             // No exception is expected in this example, but if one is still thrown from a task,
             // it will be wrapped in AggregateException and propagated to the main thread.
             catch (AggregateException e)
             {
                 Console.WriteLine( "An action has thrown an exception. THIS WAS UNEXPECTED.\n{0}" , e.InnerException.ToString());
             }
         }
 
         static void BasicAction()
         {
             Console.WriteLine( "Method=alpha, Thread={0}" , Thread.CurrentThread.ManagedThreadId);
         }
     }
}

2、并发控制疑问？

有人提出以下疑问：“如果For里面的东西，对于顺序敏感的话，会不会有问题。并行处理的话，说到底应该是多线程。如果需要Lock住什么东西的话，应该怎么做呢？例如这个例子不是对数组填充，是对文件操作呢？对某个资源操作呢？”

关于对顺序敏感的话，也就是说该如何加锁来控制？下面我举个例子来说明：对1~1000求和。如果我们想上篇那样简单地用Parallel.For，将会产生错误的结果，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {       
         static void Main( string [] args)
         {
             int loops=0;
             while (loops <= 100)
             {
                 long sum = 0;               
                 Parallel.For(1, 1001, delegate ( long i)
                 {
                     sum += i;
                 });
                 System.Console.WriteLine(sum);
                 loops++;
             }
         }
     }
}

在上述代码中，为了校验正确性我进行了重复做了100次，得出如下结果：

image图1、100次的前面部分结果

我们知道500500才是正确的答案，这说明Parallel.For不能保证对sum正确的并发执行，对此我们应该加上适当的控制，并借机来回答上面提出的如何加锁的问题。下面有几种方案可以解决这个问题：

2.1、使用Lock锁

这个我就不多解释了，直接上代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main( string [] args)
         {
             int loops = 0;
             object moniter = new object ();
             while (loops <= 100)
             {
                 long sum = 0;
                 Parallel.For(1, 1001, delegate ( long i)
                 {
                     lock (moniter) { sum += i; }
                 });
                 System.Console.WriteLine(sum);
                 loops++;
             }
         }
     }
}

我们加上lock锁之后就会得出正确的结果。

2.2、使用PLINQ——用AsParallel

关于PLINQ，以后将会介绍到，这里不会详细介绍，感兴趣的自行查阅资料。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main( string [] args)
         {
             int loops = 0;
             while (loops <= 100)
             {
                 long sum = 0;    
                 sum = Enumerable.Range(0, 1001).AsParallel().Sum();
                 System.Console.WriteLine(sum);
                 loops++;
             }
         }
     }
}

运行可以得到正确的结果。

2.3、使用PLINQ——用ParallelEnumerable

这个也不多说，直接上代码，因为关于PLINQ将在以后详细介绍，感兴趣的自行查阅资料。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main( string [] args)
         {
             int loops = 0;
             while (loops <= 100)
             {
                 long sum = 0;
                 sum = ParallelEnumerable.Range(0, 1001).Sum();
                 System.Console.WriteLine(sum);
                 loops++;
             }
         }
     }
}

运行同样可以得到正确结果。

2.4、使用Interlocked操作

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main( string [] args)
         {
             int loops = 0;
             while (loops <= 100)
             {
                 long sum = 0;
                 Parallel.For(1, 1001, delegate ( long i)
                 {
                     Interlocked.Add( ref sum, i);
                 });
                 System.Console.WriteLine(sum);
                 loops++;
             }
 
         }
     }
}

运行可以得到正确结果。

2.5、使用Parallel.For的有Thread-Local变量重载函数

这个方法已经在1.2中介绍，这里直接上代码，代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
 
namespace ConsoleApplication2
{
     class Program
     {
         static void Main( string [] args)
         {
             int loops = 0;
             while (loops <= 100)
             {
                 int sum = 0;
                 Parallel.For(0, 1001, () => 0, (i, state,subtotal) =>
                 {
                     subtotal += i;
                     return subtotal;
                 },
                 partial => Interlocked.Add( ref sum, partial));
 
                 System.Console.WriteLine(sum);
                 loops++;
             }
 
         }
     }
}

运行可得正确结果。

3、性能比较

上面的解决方案那个比较好呢？请大家各抒己见！关于这个我已经测试了一下。

 

PS:感觉写这篇的时候很累，思绪也很乱，不知大家对这篇还满意(⊙_⊙)？有什么地方需要改进，或者说不易理解，或者哪个地方错了！

文章标签：
C#
.NET
关键词：
.NET填充
数组.NET
吴秦tylerzhu
目录
相关文章
小王老师呀
|
5月前
|
测试技术 C#
.NET单元测试使用Bogus或AutoFixture按需填充的几种方式和最佳实践
【7月更文挑战第13天】AutoFixture 和 Bogus 都是流行的 C#库，用于在单元测试中按需填充测试数据。以下是它们的几种使用方式和最佳实践：一、AutoFixture：1.直接定制 2.使用匿名函数 3.实现ICustomization接口 4.使用Build方法。 二、最佳实践Bogus：1.安装2.使用。
小王老师呀
71 2
狼人2007
艾伟_转载：.NET 4.0中数组的新增功能
　　1、两数组是否“相等”？ 　　在实际开发中，有时我们需要比对两个数组是否拥有一致的元素，例如，以下两个数组由于拥有相同的元素，因此被认为是相等的： int[] arr1 = new int[]{1,2,3,4};int[] arr2 = new int[]{1,2,3,4}; 　　在.NET早期版本中，要实现上述数组比对功能，必须自己动手编写一个函数，在其内部使用循环语句逐个比较两个数组的对应元素，才知道这两个数组是否相等。
狼人2007
815 0
sktj
.NET webbrowser自动填充登录
HtmlElement name = webBrowser1.Document.GetElementById("ctl00$content$loginname"); if (name != null) name.
sktj
857 0
老朱教授
|
测试技术 C#
.NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（一）
老朱教授
1232 0
老朱教授
|
.NET C#
.NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（二）
老朱教授
1077 0
最美的回忆
|
Java Go
java中的数组与集合的排序---摘抄自:http://blog.csdn.net/jonathan_q_bo/archive/2005/11/29/539043.aspx
最美的回忆
1147 0
nicenelly
|
.NET 开发框架 数据库
asp.net:AJAX+LINQ+TreeView 动态填充多级节点
演示示例为一个学生信息查看菜单：先选择部门，再选择班级，最后选择学生姓名，查看学生信息； 效果图：      采用TreeView的SelectedNodeChanged事件作为一个包含用来显示学生信息的Lable的UpdatePanel的触发器，如下： [xhtml] view plai.
nicenelly
1196 0
zting科技
|
BI C# .NET
水晶报表填充.Net Objects数据源
zting科技
1107 0
吴秦tylerzhu
|
C# 知识图谱
.NET(C#) Internals: 以一个数组填充的例子初步了解.NET 4.0中的并行（一）
吴秦tylerzhu
1844 0
杰克.陈
|
XML C# 数据格式
.NET(C#)：在数组成员上加入XmlElement特性
原文 www.cnblogs.com/mgen/archive/2011/12/04/2276131.html 当对如下类进行XML序列化时： publicclassa {     publicint[] arr =newint[] { 1, 2, 3 }; }   结果会是：             1         2         3       数组字段会成为单独的XML元素。
杰克.陈
1022 0

热门文章

最新文章

  • 1
    java报错javax.net.ssl.SSLHandshakeException:  sun.security.validator.ValidatorException
  • 2
    快速解决idea启动项目报错:Unable to open debugger port(127.0.0.1:58950):java.net.SocketException“socket closed
  • 3
    一起谈.NET技术，ASP.NET MVC 入门介绍 (下)
  • 4
    购物车Demo,前端使用AngularJS,后端使用ASP.NET Web API(2)--前端，以及前后端Session
  • 5
    一起谈.NET技术，IoC+AOP的简单实现
  • 6
    asp.net 页面生命周期（Page lifeCycle）
  • 7
    构建ASP.NET MVC4+EF5+EasyUI+Unity2.x注入的后台管理系统（39）-在线人数统计探讨
  • 8
    乱想-ASP.NET 整个生命周期（含IIS处理）
  • 9
    ASP.NET MVC Music Store教程（3)：视图和视图模型
  • 10
    ASP.NET上传文件对文件类型的高级判断
  • 1
    .NET开源免费的Windows快速文件搜索和应用程序启动器
    114
  • 2
    【干货】Java开发者快速上手.NET指南
    82
  • 3
    .NET开源免费、功能强大的 Windows 截图录屏神器
    121
  • 4
    C#/.NET/.NET Core优秀项目和框架2024年3月简报
    204
  • 5
    ASP.NET三甲医院手术麻醉信息管理系统源码 对接麻醉机、监护仪、血气分析仪
    78
  • 6
    MQTT常见问题之调用.net sdk 报“不知道这样的主机”如何解决
    200
  • 7
    .NET智慧手术室管理平台源码
    126
  • 8
    .NET从入门到精通，零基础也能搞定的基础知识教程
    161
  • 9
    三款.NET 代码混淆工具比较分析：ConfuserEx、Obfuscar 和 Ipa Guard
    341
  • 10
    asp.net中条件查询+分页
    69

    • 相关电子书

    更多
  • Build Your Next Apache Spark Job in .NET Using Mobius
  • 低代码开发师（初级）实战教程
  • 阿里巴巴DevOps 最佳实践手册
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。