并行编程和任务（一）（并行程序开发）

并行编程和任务（一）（并行程序开发）

前言

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

共2页: 上一页12下一页

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。