ThreadPool 是MTA设计，不像STA线程可以支持Com Interop互操作。而Task是ThreadPool的再封装简化，两者都支持异步取消的操作。

ThreadPool 通过CancellationTokenSource 取消线程操作

private static void CancellingAWorkItem() {
           CancellationTokenSource cts = new CancellationTokenSource();         ThreadPool.QueueUserWorkItem(o => Count(cts.Token, 1000)); //取消线程         cts.Cancel();       } private static void Count(CancellationToken token, Int32 countTo) {
   for (Int32 count = 0; count < countTo; count++) {
   //终止线程             if (token.IsCancellationRequested) {              break;              }             Thread.Sleep(200);   // For demo, waste some time         }     }

如果在取消时还想通知或调用的其它的方法，可以针对CancellationTokenSource.Token.Register 的注册回调的方法

CancellationTokenSource cts = new CancellationTokenSource();         cts.Token.Register(() => Console.WriteLine("已经取消方法执行1"));         cts.Token.Register(() => Console.WriteLine("已经取消方法执行2"));    //执行取消操作         cts.Cancel(); //上面注册的两个Console.WriteLine会被执行

 

Task并行任务的处理（Task,Task<> 同Action,Func<>相似）,Task<>的返回结果为委托函数的返回结果

private static void DoTask() {
   //创建任务         Task
     
       t = new Task
      
       (n => Sum((Int32)n), 10000);                 t.Start(); //阻塞等待任务执行完成         t.Wait();         Console.WriteLine("The sum is: " + t.Result);   // An Int32 value     } private static Int32 Sum(Int32 n)     {
           Int32 sum = 0; for (; n > 0; n--) checked { sum += n; } return sum;     }
      
     

 PS: Task有个IsCompleted属性，也可通过循环判断这个属性来阻塞线程。 但是循环判断比Wait更浪费性能，唤醒线程毕况要比轮询调度CPU要有效率，即使你在轮询判断中增加主线程Sleep也是额外的一种消耗。

这点和异步编程模型APM很像，比如在异步执行BeginInvoke时，你可以调用EndInvoke阻塞主线程，也可以根据BeginInvoke的IAsyncReult.IsCompleted属性阻塞线程。

 

Task用一系的属性来定位异步任务的是以何种情况完成的 IsFaulted/IsCompleted/IsCanceled. 因此除了任务属性直接判断一个任务的完成情况，我们还可以通过后续任务观察前一个任务是何种方式完成的，是否有异常情况。

Task.ContinueWith((task) => { var _error = task.Exception; }, TaskContinuationOptions.OnlyOnFaulted); Task.ContinueWith(task => { var _error = task.Exception; }, TaskContinuationOptions.OnlyOnCanceled);

　　 

Task取消任务的异步操作，同样是利用CancellationTokenSource

private static void CancelTask() {
           CancellationTokenSource cts = new CancellationTokenSource();         Task
     
       t = new Task
      
       (() => Sum(cts.Token, 10000), cts.Token);         t.Start(); //取消异步任务         cts.Cancel(); try {
   //由于异步任务被取消，任务未正常完成，因此取任务结果会扔出AggregateException异常             Console.WriteLine("The sum is: " + t.Result);            } catch (AggregateException ae) {                          ae.Handle(e => e is OperationCanceledException);                         Console.WriteLine("Sum was canceled");         }     } private static Int32 Sum(CancellationToken ct, Int32 n)     {
           Int32 sum = 0; for (; n > 0; n--)         {             ct.ThrowIfCancellationRequested(); checked { sum += n; }         } return sum;     }
      
     

 

Task任务结束/中断/异常时等，以这个Task任务做为另一个任务开始的参数，可以通过Task.ContinueWith启动另一个任务执行。

private static void ContinueWith() {
           Task
     
       t = new Task
      
       (n => Sum((Int32)n), 10000);              t.Start();         Task cwt = t.ContinueWith(task => Console.WriteLine("The sum is: " + task.Result));         cwt.Wait();       }
      
     

PS：Task.ContinueWith有多个重载，其中第6个重载枚举参数TaskContinuationOptions 可以控制在多种情况下延续任务执行 ，比如在异常/完成/取消/才执行另外的一个任务

 

Task并行多个子任务（比如类似多线程下载的情况：不停的阻塞主线程任务，并且跟踪所有子线程完任务成情况），当然我们用线程也可以解决这些问题，但是 Task简化了这些代码，优化了线程资源使用与回收。

private static void ParentChildTaskDemo() {
           Task
     
       parent = new Task
      
       (() => {
   var results = new Int32[3];   new Task(() => results[0] = Sum(10000), TaskCreationOptions.AttachedToParent).Start(); new Task(() => results[1] = Sum(20000), TaskCreationOptions.AttachedToParent).Start(); new Task(() => results[2] = Sum(30000), TaskCreationOptions.AttachedToParent).Start(); return results;         }); //ContinueWith的任务必须等Parent下的所有子任务全部执行完成才会触发         var cwt = parent.ContinueWith(parentTask => Array.ForEach(parentTask.Result, Console.WriteLine)); //开启并行多任务         parent.Start(); //等待所有任务执行完成         cwt.Wait();     }
      
     

枚举TaskCreationOptions，指定了子任务以何种方式创建与执行。当然还可以利用TaskFactory实现上述方式

Task
     
       parent = new Task
      
       (() => {
   var results = new Int32[3];   var cts = new CancellationTokenSource(); //var tf = new TaskFactory
       
        (cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); //var tf = new TaskFactory
        
         (); //var tf = new TaskFactory
         
          (cts.Token);             var tf = new TaskFactory
          
           (TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously); var childTasks = new[] { tf.StartNew(() => results[0] = Sum(10000)), tf.StartNew(() => results[1] = Sum(20000)), tf.StartNew(() => results[2] = Sum(30000)) }; return results; });
          
         
        
       
      
     

当然你还可以变态点这么写

Task parent = Task.Factory.StartNew(             () => Task.Factory.StartNew(                 () => Task.Factory.StartNew(                     ()=>Task.Factory.StartNew(                            o=>Console.WriteLine(o.ToString()),"测试"                         ))));

Task还支持异步编程模型（APM），参照这段代码

Task.Factory.FromAsync
     
      (webRequest.BeginGetResponse, webRequest.EndGetResponse, null, TaskCreationOptions.None);
     

Task.Factory.FromAsync的其中一个重载首个参数为异步模型BeginInvoke方法，第二个参数为EndInvoke方法，第三个参数object为首个方法的参数，第四个参数为任务类型枚举，其返回类型为第二个方法的返回类型。

Task的延续任务及工厂方式支持异步UI操作  TaskContinuationOptions.ExecuteSynchronously/ TaskScheduler.FromCurrentSynchronizationContext()

上面仅是CLR的读书笔记，想了解很多理论知识，可以参考CLR Via这本MVP联袂推荐的书。

Task相比手动ThreadPool/Thread编码 简化了一系列任务的并行与串行执行问题，以及子任务的执行情况的控制回调变得相对容易。下面是很久以前写的一个多线程同步数据的例子，原理就是通过线程任务集合对象的所有属性的Finish情况来阻塞等待执行最后的任务。4.0编程下Task方便了这些操作，但是3.5以下我们仍然只能这样实现。

public abstract class MultiThreadWork     {        public void StartThreadWork(DataTable dtQueue, int taskCount, string userId, string userName)        {            try            {                //初始线程范围条件  计算每个线程应该接收范围大小                int averageSize = dtQueue.Rows.Count / taskCount;//平均分配                int lastSize = averageSize + dtQueue.Rows.Count % taskCount;//剩余部分由最后一个线程完成                //生成参数线程对象                List
     
       list = new List
      
       ();                for (int i = 0; i < taskCount; i++)                {                    WorkItem item = new WorkItem();                    item.DtQueue = dtQueue;                    item.IsFinish = false;                    item.UserId = userId;                    item.UserName = userName;                    item.StarIndex = averageSize * i;//每个线程接起始点                    if (i < taskCount - 1)                        item.EndIndex = item.StarIndex + averageSize;//每个线程接收结束点                                       else                        item.EndIndex = item.StarIndex + lastSize;  //最后一个结束点                    list.Add(item);                }                //开启工作线程                foreach (WorkItem item in list)                {                    ThreadPool.QueueUserWorkItem(new WaitCallback(DoWork), item);                }                //阻塞主线程 等待所有子线程结束                while (true)                {                    //bool isAllFinish = true;                    if (!list.Exists(o => o.IsFinish == false))                        break;                    else                        Thread.Sleep(500);                }                //通知订阅对象                AllWorkEventArgs args = new AllWorkEventArgs                {                    DtQueue = dtQueue,                    IsError = false                };                this.AllFinishNotify(args);            }            catch (Exception ex)            {                //通知订阅对象                AllWorkEventArgs args = new AllWorkEventArgs                {                    DtQueue = dtQueue,                    IsError = true,                    ErrorInfo = ex.Message                };                this.AllErrorNotify(args);            }        }        /// 
       
        /// 任务工作方式        /// 
        /// 
               public virtual void DoWork(object state)        {            WorkItem item = state as WorkItem;            try            {                //ClientFileService service = new ClientFileService();                //service.UploadFile(item.QueueList, item.StarIndex, item.EndIndex, item.UserId, item.UserName);                //通知订阅对象                WorkEventArgs args = new WorkEventArgs();                args.IsError = false;                args.WorkItem = item;                this.SubFinishNotity(args);            }            catch (Exception ex)            {                //通知订阅对象                WorkEventArgs args = new WorkEventArgs();                args.IsError = true;                args.ErrorInfo = ex.Message;                args.WorkItem = item;                this.SubErrorNotify(args);            }            finally            {                //子线程完成标志                item.IsFinish = true;            }        }        #region 通知事件        /// 
       
        /// 错误通知        /// 
        public event EventHandler
       
         SubError;        /// 
        
        /// 全部下载完成通知        /// 
        public event EventHandler
        
          AllFinished;        /// 
         
        /// 子线程完成通知        /// 
        public event EventHandler
         
           SubFinished;        public event EventHandler
          
            AllError; /// 
           
 /// 全部任务完成触发事件通知方法 /// 
 protected void AllFinishNotify(AllWorkEventArgs args) { if (AllFinished != null) { AllFinished(this, args); } } protected void AllErrorNotify(AllWorkEventArgs args) { if (AllError != null) { AllError(this, args); } } /// 
           
 /// 子任务线程出错触发事件通知方法 ///  protected void SubErrorNotify(WorkEventArgs args) { if (SubError != null) { SubError(this, args); } } /// 
 /// 子任务线程完成触发事件通知方法 /// 
 ///  protected void SubFinishNotity(WorkEventArgs args) { if (SubFinished != null) { SubFinished(this, args); } } #endregion }