门户网站平台建设方案,京津冀协同发展建议,中国制造加工网官网,wordpress 页脚地图上一节我们介绍了线程池相关的概念以及用法。我们可以发现ThreadPool. QueueUserWorkItem是一种起了线程之后就不管了的做法。但是实际应用过程#xff0c;我们往往会有更多的需求#xff0c;比如如何更简单的知道线程池里面的某些线程什么时候结束#xff0c;线程结束后如何…上一节我们介绍了线程池相关的概念以及用法。我们可以发现ThreadPool. QueueUserWorkItem是一种起了线程之后就不管了的做法。但是实际应用过程我们往往会有更多的需求比如如何更简单的知道线程池里面的某些线程什么时候结束线程结束后如何执行别的任务。Task可以说是ThreadPool的升级版在线程任务调度并行编程中都有很大的作用。
创建并且初始化Task
使用lambda表达式创建Task 1 2 3 4 Task.Factory.StartNew(() Console.WriteLine(Hello from a task!)); var task new Task(() Console.Write(Hello)); task.Start(); 用默认参数的委托创建Task 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 using System; using System.Threading.Tasks; namespace MultiThread { class ThreadTest { static void Main() { var task Task.Factory.StartNew(state Greet(Hello), Greeting); Console.WriteLine(task.AsyncState); // Greeting task.Wait(); } static void Greet(string message) { Console.Write(message); } } } 这种方式的一个优点是task.AsyncState作为一个内置的属性可以在不同线程中获取参数的状态。
System.Threading.Tasks.TaskCreateOptions
创建Task的时候我们可以指定创建Task的一些相关选项。在.Net 4.0中有如下选项
LongRunning
用来表示这个Task是长期运行的这个参数更适合block线程。LongRunning线程一般回收的周期会比较长因此CLR可能不会把它放到线程池中进行管理。
PreferFairness
表示让Task尽量以公平的方式运行避免出现某些线程运行过快或者过慢的情况。
AttachedToParent
表示创建的Task是当前线程所在Task的子任务。这一个用途也很常见。
下面的代码是创建子任务的示例 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 using System; using System.Threading; using System.Threading.Tasks; namespace MultiThread { class ThreadTest { public static void Main(string[] args) { Task parent Task.Factory.StartNew(() { Console.WriteLine(I am a parent); Task.Factory.StartNew(() // Detached task { Console.WriteLine(I am detached); }); Task.Factory.StartNew(() // Child task { Console.WriteLine(I am a child); }, TaskCreationOptions.AttachedToParent); }); parent.Wait(); Console.ReadLine(); } } } 如果你等待你一个任务结束你必须同时等待任务里面的子任务结束。这一点很重要尤其是你在使用Continue的时候。(后面会介绍)
等待Task
在ThreadPool内置的方法中无法实现的等待在Task中可以很简单的实现了 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 using System; using System.Threading; using System.Threading.Tasks; namespace MultiThread { class ThreadTest { static void Main() { var t1 Task.Run(() Go(null)); var t2 Task.Run(() Go(123)); Task.WaitAll(t1, t2);//等待所有Task结束 //Task.WaitAny(t1, t2);//等待任意Task结束 } static void Go(object data) // data will be null with the first call. { Thread.Sleep(5000); Console.WriteLine(Hello from the thread pool! data); } } } 注意
当你调用一个Wait方法时当前的线程会被阻塞直到Task返回。但是如果Task还没有被执行这个时候系统可能会用当前的线程来执行调用Task而不是新建一个这样就不需要重新创建一个线程并且阻塞当前线程。这种做法节省了创建新线程的开销也避免了一些线程的切换。但是也有缺点当前线程如果和被调用的Task同时想要获得一个lock就会导致死锁。
Task异常处理
当等待一个Task完成的时候调用Wait或者或者访问Result属性的时候Task任务中没有处理的异常会被封装成AggregateException重新抛出InnerExceptions属性封装了各个Task没有处理的异常。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 using System; using System.Threading.Tasks; namespace MultiThreadTest { class Program { static void Main(string[] args) { int x 0; Taskint calc Task.Factory.StartNew(() 7 / x); try { Console.WriteLine(calc.Result); } catch (AggregateException aex) { Console.Write(aex.InnerException.Message); // Attempted to divide by 0 } } } } 对于有父子关系的Task子任务未处理的异常会逐层传递到父Task并且最后包装在AggregateException中。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 using System; using System.Threading.Tasks; namespace MultiThreadTest { class Program { static void Main(string[] args) { TaskCreationOptions atp TaskCreationOptions.AttachedToParent; var parent Task.Factory.StartNew(() { Task.Factory.StartNew(() // Child { Task.Factory.StartNew(() { throw null; }, atp); // Grandchild }, atp); }); // The following call throws a NullReferenceException (wrapped // in nested AggregateExceptions): parent.Wait(); } } } 取消Task
如果想要支持取消任务那么在创建Task的时候需要传入一个CancellationTokenSouce
示例代码 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 using System; using System.Threading; using System.Threading.Tasks; namespace MultiThreadTest { class Program { static void Main(string[] args) { var cancelSource new CancellationTokenSource(); CancellationToken token cancelSource.Token; Task task Task.Factory.StartNew(() { // Do some stuff... token.ThrowIfCancellationRequested(); // Check for cancellation request // Do some stuff... }, token); cancelSource.Cancel(); try { task.Wait(); } catch (AggregateException ex) { if (ex.InnerException is OperationCanceledException) Console.Write(Task canceled!); } Console.ReadLine(); } } } 任务的连续执行
Continuations
任务调度也是常见的需求Task支持一个任务结束之后执行另一个任务。 1 2 Task task1 Task.Factory.StartNew(() Console.Write(antecedant..)); Task task2 task1.ContinueWith(task Console.Write(..continuation)); Continuations 和TaskTResult
Task也有带返回值的重载示例代码如下 1 2 3 4 Task.Factory.StartNewint(() 8) .ContinueWith(ant ant.Result * 2) .ContinueWith(ant Math.Sqrt(ant.Result)) .ContinueWith(ant Console.WriteLine(ant.Result)); // output 4 子任务
前面提到了当你等待一个任务的时候同时需要等待它的子任务完成。
下面代码演示了带子任务的Task 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 using System; using System.Threading.Tasks; using System.Threading; namespace MultiThreadTest { class Program { public static void Main(string[] args) { Taskint[] parentTask Task.Factory.StartNew(() { int[] results new int[3]; Task t1 new Task(() { Thread.Sleep(3000); results[0] 0; }, TaskCreationOptions.AttachedToParent); Task t2 new Task(() { Thread.Sleep(3000); results[1] 1; }, TaskCreationOptions.AttachedToParent); Task t3 new Task(() { Thread.Sleep(3000); results[2] 2; }, TaskCreationOptions.AttachedToParent); t1.Start(); t2.Start(); t3.Start(); return results; }); Task finalTask parentTask.ContinueWith(parent { foreach (int result in parent.Result) { Console.WriteLine(result); } }); finalTask.Wait(); Console.ReadLine(); } } } 这段代码的输出结果是 1,2,3
FinalTask会等待所有子Task结束后再执行。
TaskFactory
关于TaskFactory上面的例子中我们使用了System.Threading.Tasks .Task.Factory属性来快速的创建Task。当然你也可以自己创建TaskFactory你可以指定自己的TaskCreationOptionsTaskContinuationOptions来使得通过你的Factory创建的Task默认行为不同。
.Net中有一些默认的创建Task的方式由于TaskFactory创建Task的默认行为不同可能会导致一些不容易发现的问题。
如在.NET 4.5中Task加入了一个Run的静态方法
Task.Run(someAction);
如果你用这个方法代替上面例子中的Task.Factory.StartNew就无法得到正确的结果。原因是Task.Run创建Task的行为默认是默认是拒绝添加子任务的。上面的代码等价于 Task.Factory.StartNew(someAction, CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.Default);
你也可以创建具有自己默认行为的TaskFactory。 无论ThreadPool也好或者Task微软都是在想进办法来实现线程的重用来节省不停的创建销毁线程带来的开销。线程池内部的实现可能在不同版本中有不同的机制。如果可能的话使用线程池来管理线程仍然是建议的选择。 我们主要介绍了一下Task的基本用法在我们编程过程中有一些使用Task来提升程序性能的场景往往是很相似的微软为了简化编程在System.Threading.Tasks.Parallel中封装了一系列的并行类内部也是通过Task来实现的。
Parallel的ForForeachInvoke 方法
在编程过程中我们经常会用到循环语句 1 2 3 4 for (int i 0; i 10; i) { DoSomeWork(i); } 如果循环过程中的工作可以是并行的话那么我们可以用如下语句 1 Parallel.For(0, 10, i DoSomeWork(i)); 我们也经常会使用Foreach来遍历某个集合 1 2 3 4 foreach (var item in collection) { DoSomeWork(item); } 如果我们用一个线程池来执行里面的任务那么我们可以写成 1 Parallel.ForEach(collection, item DoSomeWork(item)); 最后如果你想并行的执行几个不同的方法你可以 1 Parallel.Invoke(Method1, Method2, Method3); 如果你看下后台的实现你会发现基本都是基于Task的线程池当然你也可以通过手动创建一个Task集合然后等待所有的任务结束来实现同样的功能。上面的Parallel.For和Parallel.Forach方法并不意味着你可以寻找你代码里面所有用到For和Foreach方法并且替代他们因为每一个任务都会分配一个委托并且在线程池里执行如果委托里面的任务是线程不安全的你可能还需要lock来保证线程安全使用lock本身就会造成性能上的损耗。如果每一个任务都是需要长时间执行并且线程安全的Parallel会给你带来不错的性能提升。对于短任务或者线程不安全的任务你需要权衡下你是否真的需要使用Parallel。 作者独上高楼 出处http://www.cnblogs.com/myprogram/ 本文版权归作者和博客园共有欢迎转载但未经作者同意必须保留此段声明且在文章页面明显位置给出原文连接否则保留追究法律责任的权利。
