CLR Via笔记之ThreadPool/Task

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<Int32> t = new Task<Int32>(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<Int32> t = new Task<Int32>(() => 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<Int32> t = new Task<Int32>(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<Int32[]> parent = new Task<Int32[]>(() => {
            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<Int32[]> parent = new Task<Int32[]>(() => {
            var results = new Int32[3];   
            var cts = new CancellationTokenSource();
            //var tf = new TaskFactory<Int32>(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
            //var tf = new TaskFactory<Int32>();
            //var tf = new TaskFactory<Int32>(cts.Token);
            var tf = new TaskFactory<Int32>(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<WebResponse>(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以下我们仍然只能这样实现。

　　


 

posted on   小城岁月  阅读(1700)  评论(1)  编辑  收藏  举报

编辑推荐：
· Linux系列：如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列（二）：开始使用ML.NET
· 记一次.NET内存居高不下排查解决与启示
· 探究高空视频全景AR技术的实现原理
· 理解Rust引用及其生命周期标识（上）
阅读排行：
· 阿里最新开源QwQ-32B，效果媲美deepseek-r1满血版，部署成本又又又降低了！
· 单线程的Redis速度为什么快？
· 展开说说关于C#中ORM框架的用法！
· SQL Server 2025 AI相关能力初探
· Pantheons：用 TypeScript 打造主流大模型对话的一站式集成库

导航

< 2011年11月 >
日 一 二 三 四 五 六
30 31 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 1 2 3
4 5 6 7 8 9 10
面朝大海，春暖花开！
点击右上角即可分享
微信分享提示