C# 4.0 并行计算部分
沿用微软的写法，System.Threading.Tasks.::.Parallel类，提供对并行循环和区域的支持。我们会用到的方法有For，ForEach，Invoke。
一、简单使用
首先我们初始化一个List用于循环，这里我们循环10次。（后面的代码都会按这个标准进行循环）
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）
二、并行循环的中断和跳出
当在进行循环时，偶尔会需要中断循环或跳出循环。下面是两种跳出循环的方法Stop和Break，LoopState是循环状态的参数。
/// <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会执行完毕所有符合条件的项。
三、并行循环中为数组/集合添加项
上面的应用场景其实并不是非常多见，毕竟只是为了遍历一个数组内的资源，我们更多的时候是为了遍历资源，找到我们所需要的。那么请继续看。
下面是我们一般会想到的写法：
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命名空间下。
四、返回集合运算结果/含有局部变量的并行循环
使用循环的时候经常也会用到迭代，那么在并行循环中叫做含有局部变量的循环。下面的代码中详细的解释，这里就不啰嗦了。
/// <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:并行循环中的迭代，确实很伤人。代码太难理解了。
五、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的东西很繁杂，但是都只是几个简单的方法，熟悉下方法就好了。
相关推荐
8. **异步编程模型**（Task Parallel Library, TPL）：虽然C# 4.0本身并未引入异步关键字，但引入了TPL库，为编写并行和异步代码提供了基础框架，为后来的`async/await`特性奠定了基础。 9. **自动属性**：自动属性...
C#4.0是微软.NET Framework的重要组成部分，它在C#3.0的基础上进行了多方面的改进和增强。这本书首先会引导你了解C#的基础知识，包括变量、数据类型、控制流结构（如if语句和循环）、函数以及类等核心概念。这些基础...
《C#4.0权威指南》是一本深受程序员喜爱的C#编程教程，全面而深入地介绍了C# 4.0版本的各种特性和技术。这本书不仅适合初学者，也适合有一定经验的开发者，帮助他们提升在.NET框架下使用C#进行软件开发的专业技能。 ...
C# 4.0是.NET Framework的重要组成部分，它带来了许多增强的功能，使得开发更加高效且灵活。 首先，C# 4.0引入了动态类型（dynamic），这是一个非常关键的变化。动态类型允许在运行时确定变量的实际类型，这对于与...
C# 4.0是微软开发的一种面向对象的编程语言，它是.NET Framework的一部分。此版本在C# 3.0的基础上进行了若干关键性的改进和扩展，旨在提升语言的灵活性和兼容性。以下是一些C# 4.0中的关键知识点： 1. **动态类型...
《C# 4.0完全参考手册》是一本详尽阐述C#编程语言第四版的权威指南，旨在帮助开发者深入理解和充分利用C# 4.0的特性与功能。该书全面覆盖了C#语言的基础、高级概念以及在.NET Framework 4.0环境下的应用。 一、C# ...
3. **多线程与并发**：C# 4.0通过`Task`类和`Task Parallel Library (TPL)`，提升了对多核处理器的利用，简化了并行编程，增强了程序的执行效率。 4. **异步编程（Asynchronous Programming）**：C# 4.0引入了`...
为了更好地利用多核处理器的优势，C# 4.0增强了对并行编程的支持。这主要通过引入新的并行编程库（PLINQ）来实现，该库基于现有的LINQ技术。 **示例代码**： ```csharp public IEnumerable<ProductInfo> ...
《C# 4.0权威指南》注重实践，包含大量有价值的示例代码，可操作性极强。 全书分为三个部分：准备篇首先对.net体系结构进行了全面的介绍，能帮助所有.net相关技术的读者建立.net的大局观，对初学者尤为重要，接着用...
此为C#4.0捷径教程 一书的配套源码 好评如潮的C# 4.0实战图书 汲取.NET技术精髓的捷径 专章讲述习惯用法与设计模式 本书是经典教程的全面升级，通过许多精彩的示例介绍了C# 语言的每个新特性，深入浅出地讲解了C#...
附件里有两个pdf，内容完全一样，似乎清晰度不一样 984 pages Publisher: Addison-Wesley Professional; 3 edition (March 20, 2010) Language: English ISBN-10: 0321694694 ISBN-13: 978-0321694690 ...
为了更好地支持多核处理器和并发编程，C# 4.0 加强了对并行编程的支持，引入了新的并行集合类型以及并行循环等特性，使得编写高性能并发应用变得更加容易。 #### 3. 扩展方法和命名空间别名 扩展方法在C# 3.0中...
C# 4.0是.NET Framework的重要组成部分，它在C# 3.0的基础上引入了许多新特性，使得开发者可以编写出更高效、更灵活的代码。以下是C# 4.0的一些核心知识点： 1. **动态类型（Dynamic）**：C# 4.0引入了动态类型，...
Essential C# 4.0已经是第三版，从发布以来受到广大.Net开发人员的关注。该书详细介绍C#在.Net Framework 4.0中的应用，介绍C# 4.0新特征，适合.Net开发人员作为参考书使用。
《C#4.0权威指南》是一本专为C#开发者设计的专业教程，全面涵盖了C#4.0语言的所有核心特性和高级主题。这本书旨在帮助读者深入理解C#编程语言，提升开发技能，并掌握.NET Framework的最新功能。通过阅读本书，开发者...
作为“Nutshell”系列的一部分，本书继承了该系列简洁明了、内容丰富的特点，并深入探讨了C# 4.0的新特性和高级主题。 #### 版权信息与出版历史 本书由O'Reilly Media, Inc.出版，自2002年第一版以来经历了多次...
### C#4.0的新特性详解 随着Visual Studio 2010的正式发布，C#4.0作为其中的一项重要更新，引入了一系列新的特性，这些特性极大地提升了开发者的编程体验，并增强了C#语言的功能性。本文将详细介绍C#4.0中的两个...