-
C#教程之并行编程和任务（一）
试听地址 https://www.xin3721.com/eschool/CSharpxin3721/
前言
并发、并行。同步、异步、互斥、多线程。我太难了。被这些词搞懵了。前面我们在写.Net基础系列的时候写过了关于.Net的异步编程。那么其他的都是些什么东西呀。今天我们首先就来解决这个问题。把这些词搞懂搞透。理清逻辑。然后最后我们进入并行编程的介绍。
概念初识
首先我们看并发和并行：
并发：并发指的是在操作系统中，一个是时间段内有多个程序在运行，但是呢。这几个程序都运行在同一个处理机上，并且任意时间点都是一个程序运行在处理机上。
并行：并行指的是在操作系统中，一个时间段内有多个程序在运行，但是呢。这几个程序分别运行在不同的处理机上。也就是说这些程序是一起运行的。
简单理解也就是并发就像三个包子给一个人吃，一口吃一个包子。并行就是三个包子给三个人吃，三个人一口分别吃三个包子。
然后我们看看异步与多线程概念：
刚刚我们讲到并发的理解概念，其中并发包含两种关系-同步和互斥。同步和互斥我们都是相对于临界资源来谈的。
互斥：进程间相互排斥使用临界资源的现象就叫互斥。就好比进程A在访问List集合的时候，进程B也想访问，但是A在访问。B就阻塞等待A访问完成之后才去访问。
同步：进程间的关系不是临界资源的相互排斥，而是相互依赖。例如进程B需要读取一个集合结果，但是这个集合结果需要进程A返回，当进程A没有返回集合结果时，进程B就会因为没有获得信息而阻塞。当进程A返回信息。进程B就可以获得信息被唤起继续运行。
多线程：多线程可以说是程序设计的一个逻辑概念，多线程实现了线程的切换。使其看起来似乎是在同时运行多个线程一样。是进程中并发运行的一段代码。
异步：异步与同步相对应。同步是进程间相互依赖。异步是进程间相互独立。不需要等待上一个进程的结果。可以做自己的事情。
上面我们就介绍完了并发、并行、互斥、同步、多线程、异步。我们总结下其中关联吧：
异步与多线程并不相等。异步是需要达到的目的，多线程是一个是实现异步的一种手段。最后达到的目的是什么呢？就是并发中线程的切换。同步也可以实现线程切换，但是由于同步中IO等待会浪费时间，所以同步切换进程与异步切换进行就有明显的时间差距。
Parallel
今天我们介绍的是Parallel类。该类位于System.Threading.Tasks命名空间中。依次来实现数据和任务的并行性。
其中定义了并行的for和foreach的静态方法、还包含着Parallel.Invoke()用于任务的并行性。我们下面就来看看吧。
Parallel.For()
Parallel.For()方法类似于#中的for循环语句，但是Parallel.For()是可以并行运行的。不过并行运行并不保证迭代运行的顺序。我们来看看。
public static void ForEx() { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); List<Test> list = new List<Test>(); for (int i = 0; i < 100; i++) { Test test = new Test(); test.Name = "Name:" + i; test.Index = "Index:" + i; test.Time = DateTime.Now; list.Add(test); Task.Delay(10).Wait(); Console.WriteLine("C#中的for循环：" + i); } stopwatch.Stop(); Console.WriteLine("for 0-100 执行完成 耗时：{0}", stopwatch.ElapsedMilliseconds); } public static void ParallelFor() { Stopwatch stopwatch = new Stopwatch(); stopwatch.Start(); List<Test> lists = new List<Test>(); Parallel.For(1, 100, i => { Test tests = new Test(); tests.Name = "Name:" + i; tests.Index = "Index:" + i; tests.Time = DateTime.Now; lists.Add(tests); Task.Delay(10).Wait(); Console.WriteLine("Parallel中的ParallelFor循环：" + i); }); stopwatch.Stop(); Console.WriteLine("ParallelFor 0-100 执行完成 耗时：{0}", stopwatch.ElapsedMilliseconds); }
static void Main(string[] args)
{
Console.WriteLine("Start");
ForEx();
Console.WriteLine("for循环完成");
ParallelFor();
Console.WriteLine("End");
}
这里我们可以看到最后的运行结果图使用for循环的执行下来都是依次执行。按照相应的顺序。但是我们使用Parallel.For()的时候运行下来。也输出了所有的结果，但是其顺序就没有保证了。
Parallel.ForEach()
我们再看Parallel.ForEach()提供了一个并行处理数据的机制。这里类似于foreach语句，但是是以一部方式遍历。这里没有确定遍历的顺序，其执行顺序也就是不保证的。
#region ForEach 语句比较 public static void ParallelForEach() { List<Test> result = new List<Test>(); for (int i = 1; i < 100; i++) { Test model = new Test(); model.Name = "Name" + i; model.Index = "Index" + i; model.Time = DateTime.Now; result.Add(model); } Parallel.ForEach<Test>(result, s => { Console.WriteLine(s.Name); }); } #endregion
static void Main(string[] args) { ParallelForEach(); }
我们看这里的运行结果，对数据集合进行了遍历处理，但是其运行的顺序不定，是乱序的结果。这也就是异步遍历的一个表现。
ParallelLoopState
下面我们来看ParallelLoopState。它提供了两个方法。一个是Break、一个是Stop。
Break：表示并行循环执行了当前迭代后应尽快停止执行。筛选出符合条件的执行，可能输出完全。
Stop：表示并行循环应尽快停止执行。遇到符合条件后停止并行循环，可能不完全输出。
下面我们看看代码：
public static List<Test> GetListTest() { List<Test> result = new List<Test>(); for (int i = 1; i < 100; i++) { Test model = new Test(); model.Name = i.ToString(); model.Index = "Index" + i; model.Time = DateTime.Now; result.Add(model); } return result; } public static void BraekFor() { var result = GetListTest(); Parallel.For(0, result.Count, (int i, ParallelLoopState ls) => { Task.Delay(10).Wait(); if (i > 50) { Console.WriteLine("Parallel.For使用Break停止当前迭代:" + i); ls.Break(); return; } Console.WriteLine("测试Parallel.For的Break：" + i); }); } public static void StopFor() { var result = GetListTest(); Parallel.For(0, result.Count, (int i, ParallelLoopState ls) => { Task.Delay(10).Wait(); if (i > 50) { Console.WriteLine("Parallel.For使用Stop停止 迭代:" + i); ls.Stop(); return; } Console.WriteLine("测试Parallel.For的Stop：" + i); }); }
static void Main(string[] args)
{
BraekFor();
StopFor();
}
我们看对于Parallel.For()来说这个案例。使用Break()停止当前迭代会输出符合条件所有结果，但是我们使用Stop的时候输出部分的时候就停止了。
public static void BraekForEach()
{
var result = GetListTest();
Parallel.ForEach<Test>(result, (Test s, ParallelLoopState ls) =>
{
Task.Delay(10).Wait();
if (Convert.ToInt32(s.Name) > 50)
{
Console.WriteLine("Parallel.ForEach使用Break停止当前迭代:" + s.Name);
ls.Break();
return;
}
Console.WriteLine("测试Parallel.ForEach的Break：" + s.Name);
});
}
public static void StopForEach()
{
var result = GetListTest();
Parallel.ForEach<Test>(result, (Test s, ParallelLoopState ls) =>
{
Task.Delay(10).Wait();
if (Convert.ToInt32(s.Name) > 50)
{
Console.WriteLine("Parallel.ForEach使用Stop停止 迭代:" + s.Name);
ls.Stop();
return;
}
Console.WriteLine("测试Parallel.ForEach的Stop：" + s.Name);
});
}
static void Main(string[] args)
{
BraekForEach();
StopForEach();
}
我们再对Parallel.ForEach进行测试，发现对于Stop和Break的用法和意义是一样的。
Parallel.Invoke()
上面我们介绍了Parallel.For和Parallel.ForEach以及提供的两个方法Break和Stop。上面介绍的这些都是对数据的并行处理执行。下面我们介绍Parallel.Invoke()。它是针对于任务的并行运行处理。
这里我们需要注意以下几点：
1、如果我们传入4个任务并行，那么我们至少需要四个逻辑处理内核(硬件线程)才可能使四个任务一起运行。但是当其中一个内核繁忙，那么底层的调度逻辑就可能会延迟某些方法的初始化执行。
2、Parallel.Invoke()所包含的并行任务不能相互依赖，因为运行执行的顺序不可保证。
3、使用Parallel.Invoke()我们需要测试运行结果，观察逻辑内核使用率以及实现加速。
4、使用Parallel.Invoke()会产生一些额外的开销，例如分配硬件线程。
我们看下面的案例：
下面我们对一个集合的数据进行添加然后输出。下面我们分为四组测试。500条数据和1000条数据各两个，分别是一般的同步任务和Parallel.Invoke()的并行任务执行。再观察其运行的时间比较。
#region Parallel.Invoke()使用共同资源
public static List<Test> _tests = null;
public static void TaskFive_One()
{
for (int i = 0; i < 500; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskFive_One 500条数据第一个方法 执行完成");
}
public static void TaskFive_Two()
{
for (int i = 500; i < 1000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskFive_Two 500条数据第二个方法 执行完成");
}
public static void TaskFive_Three()
{
for (int i = 1000; i < 1500; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskFive_Three 500条数据第三个方法 执行完成");
}
public static void TaskFive_Four()
{
for (int i = 1500; i < 2000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskFive_Four 500条数据第四个方法 执行完成");
}
public static void TaskOnethousand_One()
{
for (int i = 0; i < 1000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskOnethousand_One 1000条数据第一个方法 执行完成");
}
public static void TaskOnethousand_Two()
{
for (int i = 1000; i < 2000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskOnethousand_Two 1000条数据第二个方法 执行完成");
}
public static void TaskOnethousand_Three()
{
for (int i = 2000; i < 3000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskOnethousand_Three 1000条数据第三个方法 执行完成");
}
public static void TaskOnethousand_Four()
{
for (int i = 3000; i < 4000; i++)
{
Test test = new Test();
test.Name = i.ToString();
test.Index = i.ToString();
test.Time = DateTime.Now;
_tests.Add(test);
}
Console.WriteLine("TaskOnethousand_Three 1000条数据第四个方法 执行完成");
}
#endregion
static void Main(string[] args)
{
//五百条数据顺序完成
Stopwatch swFive = new Stopwatch();
swFive.Start();
Thread.Sleep(3000);
_tests = new List<Test>();
TaskFive_One();
TaskFive_Two();
TaskFive_Three();
TaskFive_Four();
swFive.Stop();
Console.WriteLine("500条数据 顺序编程所耗时间:" + swFive.ElapsedMilliseconds);
//五百条数据并行完成
Stopwatch swFiveTask = new Stopwatch();
swFiveTask.Start();
Thread.Sleep(3000);
_tests = new List<Test>();
Parallel.Invoke(() => TaskFive_One(), () => TaskFive_Two(), () => TaskFive_Three(), () => TaskFive_Four());
swFiveTask.Stop();
Console.WriteLine("500条数据 并行编程所耗时间:" + swFiveTask.ElapsedMilliseconds);
//一千条数据顺序完成
Stopwatch swOnethousand = new Stopwatch();
swOnethousand.Start();
Thread.Sleep(3000);
_tests = new List<Test>();
TaskOnethousand_One();
TaskOnethousand_Two();
TaskOnethousand_Three();
TaskOnethousand_Four();
swOnethousand.Stop();
Console.WriteLine("1000条数据 顺序编程所耗时间:" + swOnethousand.ElapsedMilliseconds);
//一千条数据并行完成
Stopwatch swOnethousandTask = new Stopwatch();
swOnethousandTask.Start();
Thread.Sleep(3000);
_tests = new List<Test>();
Parallel.Invoke(() => TaskOnethousand_One(), () => TaskOnethousand_Two(), () => TaskOnethousand_Three(), () => TaskOnethousand_Four());
swOnethousandTask.Stop();
Console.WriteLine("1000条数据 并行编程所耗时间:" + swOnethousandTask.ElapsedMilliseconds);
}
我们看这次的运行结果，发现我们使用顺序编程和并行编程所需要的时间相差无几的。那么怎么回事呢？我们仔细检查下，发现我们似乎对资源进行了共享。我们下面处理下，对list集合不进行共享看看。
#region Parallel.Invoke()不使用共同资源
public static void TaskFive_One()
{
List<Test> tests = new
