8龙玩转并行开发——第二天 Task的下

     

      Windows Embedded Compact
7试用本就揭晓一段时间了,微软官网提供的是在线安装包,不顶有利下载和设置。微软嵌入式中文社区提供了离线安装包之下载,地址如下:

   
 在我们询问Task之前,如果我们如果以多按的效果可能就是会自己来开线程,然而这种线程模型在.net
4.0后头让同样种叫做基于

http://download.winitpro.com.cn/MS/MSEmbed/WinCompact7evaluation_1.rar
http://download.winitpro.com.cn/MS/MSEmbed/WinCompact7evaluation_2.rar

“任务的编程模型”所拍,因为task会比thread具有双重小的特性开销,不过大家必会时有发生疑惑,任务和线程到底出啊界别?

     
感谢David.Zang提供了利,让周边WinCE的开发人员能在第一时间接触到WinCE7.0。

 

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 }

图片 1

①:从图备受可以看两栽task实例的简练生命周期。

Created:表示默认初始化任务,但是咱发现“工厂创建的”实例直接跨越了。

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

RanToCompletion:任务执行完毕。

②:我们发现task的使用跟Thread很相像,就连waitAll的办法以呢一致,刚才也说了,任务是搭在线程之上,那么我们之所以VS里面的

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

      任务真正托管给了线程。

图片 2

 

  1. 撤消任务

 
 我们领略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         try
17         {
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

 

  1. 获任务的返回值

 
我们原先写线程的早晚报之法一般还是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         //执行task1
12         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 }

图片 4

<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         //执行task1
12         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 }

图片 5

 

4:ContinueWith结合WaitAll来娱乐同样拿

   
当这二者结合起来,我们虽得玩玩一些苛一点的事物,比如说现在时有发生7只任务,其中t1需要串行,t2-t3得互相,t4需要串行,t5-t6并尽,

t7串行。

图片 6

吓了,我们达成转代码说话,下面代码没有实际意思,纯属演示。

 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 }

图片 7