并行编程和任务（一）（深入理解并行编程豆瓣）-eolink官网

并行编程和任务（一）（深入理解并行编程豆瓣）

前言

并发、并行。同步、异步、互斥、多线程。我太难了。被这些词搞懵了。前面我们在写.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 list = new List();

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 lists = new List();

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 result = new List();

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(result, s => {

Console.WriteLine(s.Name);

});

}

#endregion

static void Main(string[] args)

{

ParallelForEach();

}

我们看这里的运行结果，对数据集合进行了遍历处理，但是其运行的顺序不定，是乱序的结果。这也就是异步遍历的一个表现。

回到顶部

ParallelLoopState

下面我们来看ParallelLoopState。它提供了两个方法。一个是Break、一个是Stop。

Break：表示并行循环执行了当前迭代后应尽快停止执行。筛选出符合条件的执行，可能输出完全。

Stop：表示并行循环应尽快停止执行。遇到符合条件后停止并行循环，可能不完全输出。

下面我们看看代码：

public static List GetListTest()

{

List result = new List();

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(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(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 _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();

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();

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();

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();

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 tests = new

Flask接口签名sign原理与实例代码浅析

259 2022-06-19

并行编程和任务（一）（深入理解并行编程豆瓣）

多平台统一管理软件接口，如何实现多平台统一管理软件接口

Flask接口签名sign原理与实例代码浅析

zookeeper python接口实例详解

推荐文章

接口调用是什么意思？几种常用接口调用方式

接口设计原则

8款在线 API 接口文档管理工具

api管理系统是什么？

什么是接口调试？接口调试的步骤有哪些？

api 接口管理系统有哪些？

接口测试有几种测试方法

API文档生成工具有哪些？

微服务和api网关区别

交换机配置步骤

最近发表

热评文章

在线接口文档管理工具推荐，支持在线测试，HTTP接口

开源的在线接口文档wiki工具Mindoc的介绍与使

如何优雅的进行接口设计？接口设计的六大原则是什么？

什么是API测试,api检测公司

软件接口设计怎么做？前后端分离软件接口设计思路

接口管理平台推荐，几大接口管理平台总有一款适合你！

并行编程和任务（一）（深入理解并行编程 豆瓣）

推荐文章

最近发表

热评文章

并行编程和任务（一）（深入理解并行编程豆瓣）