8天玩转并行开发——第二天 Task的使用

在我们了解Task之前,如果我们要使用多核的功能可能就会自己来开线程,然而这种线程模型在.net 4.0之后被一种称为基于

“任务的编程模型”所冲击,因为task会比thread具有更小的性能开销,不过大家肯定会有疑惑,任务和线程到底有什么区别?

1:任务是架构在线程之上的,也就是说任务最终还是要抛给线程去执行。

2:任务跟线程不是一对一的关系,比如开10个任务并不是说会开10个线程,这一点任务有点类似线程池,但是任务相比线程池有很小

的开销和精确的控制。

一:Task

1. 最简单的使用

开启task有两种方式:

<1> 实例化Task

1    //第一种方式开启2         var task1 = new Task(() =>3         {4             Run1();5         });

<2>从工厂中创建

1   var task2 = Task.Factory.StartNew(() =>2             {3                 Run2();4             });

是的,同样两种方法都可以创建,我们肯定会想两者是不是多多少少有点区别呢?好的,下面我们举个例子看分晓。

 1 using System; 2 using System.Threading; 3 using System.Threading.Tasks; 4 using System.Diagnostics; 5 using System.Collections.Generic; 6  7 class Program 8 { 9     static void Main(string[] args)10     {11         //第一种方式开启12         var task1 = new Task(() =>13         {14             Run1();15         });16 17         //第二种方式开启18         var task2 = Task.Factory.StartNew(() =>19             {20                 Run2();21             });22 23         Console.WriteLine("调用start之前****************************\n");24 25         //调用start之前的“任务状态”26         Console.WriteLine("task1的状态:{0}", task1.Status);27 28         Console.WriteLine("task2的状态:{0}", task2.Status);29 30         task1.Start();31 32         Console.WriteLine("\n调用start之后****************************");33 34         //调用start之前的“任务状态”35         Console.WriteLine("\ntask1的状态:{0}", task1.Status);36 37         Console.WriteLine("task2的状态:{0}", task2.Status);38 39         //主线程等待任务执行完40         Task.WaitAll(task1, task2);41 42         Console.WriteLine("\n任务执行完后的状态****************************");43 44         //调用start之前的“任务状态”45         Console.WriteLine("\ntask1的状态:{0}", task1.Status);46 47         Console.WriteLine("task2的状态:{0}", task2.Status);48 49         Console.Read();50     }51 52     static void Run1()53     {54         Thread.Sleep(1000);55         Console.WriteLine("\n我是任务1");56     }57 58     static void Run2()59     {60         Thread.Sleep(2000);61         Console.WriteLine("我是任务2");62     }63 }

①:从图中可以看出两种task实例的简略生命周期。

Created:表示默认初始化任务,但是我们发现“工厂创建的”实例直接跳过。

WaitingToRun: 这种状态表示等待任务调度器分配线程给任务执行。

RanToCompletion:任务执行完毕。

②:我们发现task的使用跟Thread很相似,就连waitAll的方法使用也一样,刚才也说了,任务是架构在线程之上,那么我们用VS里面的

“并行任务”看一看,快捷键Ctrl+D,K,或者找到“调试"->"窗口“->"并行任务“,我们在WaitAll方法处插入一个断点,最终我们发现

任务确实托管给了线程。

2. 取消任务

我们知道task是并行计算的,比如说主线程在某个时刻由于某种原因要取消某个task的执行,我们能做到吗? 当然我们可以做到。

在4.0中给我们提供一个“取消标记”叫做CancellationTokenSource.Token,在创建task的时候传入此参数,就可以将主线程和任务相

关联,然后在任务中设置“取消信号“叫做ThrowIfCancellationRequested来等待主线程使用Cancel来通知,一旦cancel被调用。task将会

抛出OperationCanceledException来中断此任务的执行,最后将当前task的Status的IsCanceled属性设为true。看起来是不是很抽象,

没关系,上代码说话。

 1 using System; 2 using System.Threading; 3 using System.Threading.Tasks; 4 using System.Diagnostics; 5 class Program 6 { 7     static void Main(string[] args) 8     { 9         var cts = new CancellationTokenSource();10         var ct = cts.Token;11 12         Task task1 = new Task(() => { Run1(ct); }, ct);13 14         Task task2 = new Task(Run2);15 16         try17         {18             task1.Start();19             task2.Start();20 21             Thread.Sleep(1000);22 23             cts.Cancel();24 25             Task.WaitAll(task1, task2);26         }27         catch (AggregateException ex)28         {29             foreach (var e in ex.InnerExceptions)30             {31                 Console.WriteLine("\nhi,我是OperationCanceledException:{0}\n", e.Message);32             }33 34             //task1是否取消35             Console.WriteLine("task1是不是被取消了? {0}", task1.IsCanceled);36             Console.WriteLine("task2是不是被取消了? {0}", task2.IsCanceled);37         }38 39         Console.Read();40     }41 42     static void Run1(CancellationToken ct)43     {44         ct.ThrowIfCancellationRequested();45 46         Console.WriteLine("我是任务1");47 48         Thread.Sleep(2000);49 50         ct.ThrowIfCancellationRequested();51 52         Console.WriteLine("我是任务1的第二部分信息");53     }54 55     static void Run2()56     {57         Console.WriteLine("我是任务2");58     }59 }

从图中可以看出

①:Run1中的Console.WriteLine("我是任务1的第二部分信息"); 没有被执行。

②:Console.WriteLine("task1是不是被取消了? {0}", task1.IsCanceled); 状态为True。

也就告诉我们Run1中途被主线程中断执行,我们coding的代码起到效果了。

3. 获取任务的返回值

我们以前写线程的时候注册的方法一般都是void类型,如果主线程要从工作线程中获取数据一般采用的手段是“委托+事件”的模式,然而

在Task中有两种方式可以解决。

<1>  现在我们的实例化是采用Task<TResult>的形式,其中TResult就是当前task执行后返回的结果,下面举得例子是t2任务获取

t1的执行结果。

 1 using System; 2 using System.Threading; 3 using System.Threading.Tasks; 4 using System.Diagnostics; 5 using System.Collections.Generic; 6  7 class Program 8 { 9     static void Main(string[] args)10     {11         //执行task112         var t1 = Task.Factory.StartNew<List<string>>(() => { return Run1(); });13 14         t1.Wait();15 16         var t2 = Task.Factory.StartNew(() =>17         {18             Console.WriteLine("t1集合中返回的个数:" + string.Join(",", t1.Result));19         });20 21         Console.Read();22     }23 24     static List<string> Run1()25     {26         return new List<string> { "1", "4", "8" };27     }28 }

<2>采用ContinueWith方法,很有意思,现在我们将上面的方法改造一下。

 1 using System; 2 using System.Threading; 3 using System.Threading.Tasks; 4 using System.Diagnostics; 5 using System.Collections.Generic; 6  7 class Program 8 { 9     static void Main(string[] args)10     {11         //执行task112         var t1 = Task.Factory.StartNew<List<string>>(() => { return Run1(); });13 14         var t2 = t1.ContinueWith((i) =>15         {16             Console.WriteLine("t1集合中返回的个数:" + string.Join(",", i.Result));17         });18 19         Console.Read();20     }21 22     static List<string> Run1()23     {24         return new List<string> { "1", "4", "8" };25     }26 }

4:ContinueWith结合WaitAll来玩一把

当这两者结合起来,我们就可以玩一些复杂一点的东西,比如说现在有7个任务,其中t1需要串行,t2-t3可以并行,t4需要串行,t5-t6并行,

t7串行。

好了,我们上一下代码说话,下面代码没有实际意思,纯属演示。

 1 using System; 2 using System.Threading; 3 using System.Threading.Tasks; 4 using System.Diagnostics; 5 using System.Collections.Generic; 6 using System.Collections.Concurrent; 7  8 class Program 9 {10     static void Main(string[] args)11     {12         ConcurrentStack<int> stack = new ConcurrentStack<int>();13 14         //t1先串行15         var t1 = Task.Factory.StartNew(() =>16         {17             stack.Push(1);18             stack.Push(2);19         });20 21         //t2,t3并行执行22         var t2 = t1.ContinueWith(t =>23         {24             int result;25 26             stack.TryPop(out result);27         });28 29         //t2,t3并行执行30         var t3 = t1.ContinueWith(t =>31         {32             int result;33 34             stack.TryPop(out result);35         });36 37         //等待t2和t3执行完38         Task.WaitAll(t2, t3);39 40 41         //t4串行执行42         var t4 = Task.Factory.StartNew(() =>43         {44             stack.Push(1);45             stack.Push(2);46         });47 48         //t5,t6并行执行49         var t5 = t4.ContinueWith(t =>50         {51             int result;52 53             stack.TryPop(out result);54         });55 56         //t5,t6并行执行57         var t6 = t4.ContinueWith(t =>58         {59             int result;60 61             //只弹出,不移除62             stack.TryPeek(out result);63         });64 65         //临界区:等待t5,t6执行完66         Task.WaitAll(t5, t6);67 68         //t7串行执行69         var t7 = Task.Factory.StartNew(() =>70         {71             Console.WriteLine("当前集合元素个数:" + stack.Count);72         });73 74         Console.Read();75     }76 }

原文地址:https://www.cnblogs.com/Jeely/p/10999319.html

时间: 2024-10-27 06:17:21

8天玩转并行开发——第二天 Task的使用的相关文章

并行开发——第二篇 Task的使用

在我们了解Task之前,如果我们要使用多核的功能可能就会自己来开线程,然而这种线程模型在.net 4.0之后被一种称为基于"任务的编程模型"所冲击,因为task会比thread具有更小的性能开销,不过大家肯定会有疑惑,任务和线程到底有什么区别? 1:任务是架构在线程之上的,也就是说任务最终还是要抛给线程去执行. 2:任务跟线程不是一对一的关系,比如开10个任务并不是说会开10个线程,这一点任务有点类似线程池,但是任务相比线程池有很小的开销和精确的控制. 一:Task 最简单的使用 开启

8天玩转并行开发——第七天 简要分析任务与线程池

原文:8天玩转并行开发--第七天 简要分析任务与线程池 其实说到上一篇,我们要说的task的知识也说的差不多了,这一篇我们开始站在理论上了解下“线程池”和“任务”之间的关系,不管是 说线程还是任务,我们都不可避免的要讨论下线程池,然而在.net 4.0以后,线程池引擎考虑了未来的扩展性,已经充分利用多核微处理器 架构,只要在可能的情况下,我们应该尽量使用task,而不是线程池. 首先看一下task的结构 从图中我们可以看出Task.Factory.StartNew()貌似等同于用ThreadPo

8天玩转并行开发——第八天 用VS性能向导解剖你的程序

原文:8天玩转并行开发--第八天 用VS性能向导解剖你的程序 最后一篇,我们来说说vs的“性能向导",通常我们调试程序的性能一般会使用Stopwatch,如果希望更加系统的了解程序,我们就需要 用到”性能向导“,通过性能报告便于我们快速的发现并找到潜在的性能问题. 首先我们上一段需要改进的代码: 1 using System; 2 using System.Collections.Generic; 3 using System.Linq; 4 using System.Text; 5 using

8天玩转并行开发——第一天 Parallel的使用

转自:http://www.cnblogs.com/huangxincheng/archive/2012/04/02/2429543.html 随着多核时代的到来,并行开发越来越展示出它的强大威力,像我们这样的码农再也不用过多的关注底层线程的实现和手工控制, 要了解并行开发,需要先了解下两个概念:“硬件线程”和“软件线程”. 1. 硬件线程 相信大家手头的电脑都是双核以上的,像我这样古董的电脑都是双核的,这样的双核叫做物理内核.

8天玩转并行开发——第四天 同步机制(上)

在并行计算中,不可避免的会碰到多个任务共享变量,实例,集合.虽然task自带了两个方法:task.ContinueWith()和Task.Factory .ContinueWhenAll()来实现任务串行化,但是这些简单的方法远远不能满足我们实际的开发需要,从.net 4.0开始,类库给我们提供了很多 的类来帮助我们简化并行计算中复杂的数据同步问题. 大体上分为二种: ①   并发集合类:           这个在先前的文章中也用到了,他们的出现不再让我们过多的关注同步细节. ②  轻量级同步

8天玩转并行开发——第六天 异步编程模型

在.net里面异步编程模型由来已久,相信大家也知道Begin/End异步模式和事件异步模式,在task出现以后,这些东西都可以被task包装 起来,可能有人会问,这样做有什么好处,下面一一道来. 一: Begin/End模式 1: 委托 在执行委托方法的时候,我们常常会看到一个Invoke,同时也有一对你或许不常使用的BeginInvoke,EndInvoke方法对,当然Invoke方法 是阻塞主线程,而BeginInvoke则是另开一个线程. 1 class Program 2 { 3 sta

8天玩转并行开发——第五天 同步机制(下)

承接上一篇,我们继续说下.net4.0中的同步机制,是的,当出现了并行计算的时候,轻量级别的同步机制应运而生,在信号量这一块 出现了一系列的轻量级,今天继续介绍下面的3个信号量 CountdownEvent,SemaphoreSlim,ManualResetEventSlim. 一:CountdownEvent 这种采用信号状态的同步基元非常适合在动态的fork,join的场景,它采用“信号计数”的方式,就比如这样,一个麻将桌只能容纳4个 人打麻将,如果后来的人也想搓一把碰碰运气,那么他必须等待

并行开发学习随笔1——plinq并行

这两天在看园友的文章 <8天玩转并行开发——第三天 plinq的使用> 对里面的第一个实例亲手实践了一下,发现了一点有意思的事情. 测试环境:.net 4.5 64位(如果是32位的,测试千万数据时会爆出out of memory的错误) 在我的机器上,千万数据的测试结果: 百万数据的测试结果: 十万数据的测试结果: 可以看出,到底使用串行还是并行应该根据数据量来决定,两者的大致就在几十万数据的时候性能基本接近.当然这个结果不是固定的,应该是与机器的配置以及测试时的系统环境有比较大的关系,实际

并行开发

8天玩转并行开发系列 http://www.cnblogs.com/huangxincheng/category/368987.html .NET Framework 中的并行编程 http://msdn.microsoft.com/en-us/library/dd460693(v=vs.110).aspx 命名空间System.Threading.Tasks http://msdn.microsoft.com/en-us/library/system.threading.tasks(v=vs.