c#基础学习----Task学习笔记（最全）

TASK Task:Task.Run

thread的问题

线程（Thread）是用来创建并发(concurrency)的一种低级别工具，它有一些限制，尤其是:
·虽然开始线程的时候可以方便的传入数据，但是当Join 的时候，很难从线程获得返回值。
- 可能需要设置一些共享字段。
- 如果操作抛出异常，捕获和传播该异常都很麻烦。
无法告诉线程在结束时开始做另外的工作，你必须进行Join 操作（在进程中阻塞当前的线程)
很难使用较小的并发(concurrent）来组建大型的并发。

解决：Task类

Task

Task是一个相对高级的抽象：它代表了一个并发操作（concurrent）
- 该操作可能由Thread支持，或不由Thread支持
Task是可组合的（可使用Continuation把它们串成链）
- Task可以使用线程池来减少启动延迟
- 使用TaskCompletionSource，Tasks 可以利用回调的方式，在等待IO绑定操作时完全避免线程。

开始使用Task:Task.Run

Task类在System.Threading.Tasksm命名空间下
开始一个Task最简单的办法就是使用Task.Run (.NET 4.5，4.0的时候是Task.Factory.StartNew)这个静态方法:
- 传个一个Action委托即可
Task默认使用线程池，也就是后台线程
- 当主线程结束时，你创建的所有Tasks都会结束
Task.Run返回一个Task,对象，可以使用它来监视其过程
- ·在Task.Run 之后，我们没有调用Start，因为该方法创建的是“热”任务(hot task（类似创建即使用）)
  - 可以通过Task 的构造函数创建“冷”任务(cold task)，但是很少这样做
可以通过Task的Status属性来跟踪Taskd的执行状态

Wait等待

调用Task的Wait方法进行阻塞直到操作完成

        static void Main(string[] args)
        {
            Task task = Task.Run(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("foo");
            });
            Console.WriteLine(task.IsCompleted);//false
            task.Wait();//阻塞直到task完成操作
            Console.WriteLine(task.IsCompleted);//true
        }

Wait也可以让你指定一个超时时间和一个消息令牌来提前结束等待

长时间运行的任务

默认情况下，CLR在线程池中运行Task，这非常适合短时间运行的Compute-Bound类工作。

针对长时间运行的任务或者阻塞操作，你可以不采用线程池

        static void Main(string[] args)
        {
            Task task = Task.Factory.StartNew(() =>
            {
                Thread.Sleep(3000);
                Console.WriteLine("foo");
            },TaskCreationOptions.LongRunning);
        }

如果同时运行多个 long-running tasks(尤其是其中有处于阻塞状态的），那么性能将会受很大影响，这时有比TaskCreationOptions.LongRunning更好的办法:·
- 如果任务是IO-Bound，TaskCompletionSource和异步函数可以让你用回调(Coninuations) 代替线程来实现并发。
- 如果任务是 Compute-Bound，生产者/消费者队列允许你对任务的并发性进行限流，避免把其他线程和进程饿死。

Task的返回值

Task有一个泛型子类叫做Task,它允许发出一个返回值。
使用Func委托或兼容的Lambda表达式来调用Task.Run就可以得到Task.
然后可以通过Result属性来获取返回的结果
- 如果这个task还没有完成操作，访问Result属性会阻塞该线程直到该task完成操作

        static void Main(string[] args)
        {
            Task task = Task.Run(() =>
            {
                Console.WriteLine("Foo");
                Thread.Sleep(3000);
                return 3;
            });
            int result = task.Result;//如果task没有完成，那么就会阻塞
            Console.WriteLine(result);
        }

        static void Main(string[] args)
        {
            //获取质数
            Task task = Task.Run(() => Enumerable.Range(2, 30000).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
            Console.WriteLine("Task runing ……");
            Console.WriteLine("The answer is "+task.Result);
        }

Task的异常

与Thread不一样，Task可以很方便的传播异常

如果你的task里面抛出一个未处理的异常（故障），那么该异常就会重新被抛出给：

调用Wait()的地方

访问了Task的Result属性的地方

        static void Main(string[] args)
        {
            Task task = Task.Run(() => { throw null; });
            try
            {
                task.Wait();
            }
            catch (AggregateException aex)
            {
                if (aex.InnerException is NullReferenceException)
                {
                    Console.WriteLine("Null");
                }
                else
                {
                    throw;
                }

            }
        }

CLR将异常包裹在AggregateRxception里，以便在并行编程场景中发挥很好的作用

不想抛出异常，想要知道问题

无需抛出异常，通过Task的IsFaulted和IsCanceled属性也可以检查出Task是否发生故障。
- 如果两个属性都返回false那么没有错误发生
- 如果IsCanceled为true那就说明OperationCanceledRxception为该Task抛出了。
- 如果lsFaulted为true，那就说明另一个类型的异常被抛出了，而Exception属性也将指明错误

异常与“自治”的Task

自治的，“设置完就不管了”的Task。就是指不通过调用Wait()方法、Result属性或continuation进行会合的任务。
针对自治的Task，需要像Thread一样，显式的处理异常，避免发生“悄无声息的故障”。

**未观察到的异常：**自治Task上未处理的异常称为未观察到的异常。

可以通过全局的 TaskScheduler.UnobservedTaskException来订阅未观察到的异常。
关于什么是“未观察到的异常”，有一些细微的差别:
- ·使用超时进行等待的 Task，如果在超时后发生故障，那么它将会产生一个“未观察到的异常”。
- 在Task 发生故障后，如果访问Task的Exception属性，那么该异常就被认为是“已观察到的”。

Continuation(继续)

一个Continuation会对 Task 说:“当你结束的时候，继续再做点其它的事”
Continuation通常是通过回调的方式实现的

        static void Main(string[] args)
        {
            Task task = Task.Run(() => Enumerable.Range(2, 30000).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
            var awaiter = task.GetAwaiter();
            awaiter.OnCompleted(() =>
            {
                int result = awaiter.GetResult();
                Console.WriteLine(result);
            });
            Console.ReadLine();
        }

在task上调用GetAwaiter会返回一个awaiter 对象
- 它的 OnCompleted方法会告诉之前的task:“当你结束/发生故障的时候要执行委托”。
可以将Continuation 附加到已经结束的task 上面，此时Continuation将会被安排立即执行。

awaiter

r任何可以暴露下列两个方法和一个属性的对象就是awaiter:
- OnCompleted：是INotifyCompleted的一部分
- GetResult
- IsCompleted的bool属性

如果发生故障

如果之前的任务发生故障，那么当Continuation代码调用awaiter.GetResult()的时候，异常会被重新抛出。
无需调用GetResult，我们可以直接访问task的 Result属性。
但调用GetResult的好处是，如果 task发生故障，那么异常会被直接的抛出，而不是包裹在AggregateException里面，这样的话catch 块就简洁很多了。

非泛型Task

针对非泛型的Task,GetResult()方法有一个void放回值，它就是用来重新抛出异常的

同步上下文

如果同步上下文出现了，那么OnCompleted 会自动捕获它，并将Continuation提交到这个上下文中。这一点在富客户端应用中非常有用，因为它会把Continuation放回到U线程中。
如果是编写一个库，则不希望出现上述行为，因为开销较大的UI线程切换应该在程序运行离开库的时候只发生一次，而不是出现在方法调用之间。所以，我们可以便用ConfigureAwait方法来避免这种行为

        static void Main(string[] args)
        {
            Task task = Task.Run(() => Enumerable.Range(2, 30000).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
            var awaiter = task.ConfigureAwait(false).GetAwaiter();
            awaiter.OnCompleted(() =>
            {
                int result = awaiter.GetResult();
                Console.WriteLine(result);
            });
            Console.ReadLine();
        }

如果没有同步上下文出现，或者你使用的是ConfigureAwait(false)，那么Continuation会运行在先前task的同一个线程上，从而避免不必要的开销

ContinueWith

另外一种附加Continuation的方式就是调用task 的 ContinueWith方法（例子continueWith)

        static void Main(string[] args)
        {
            Task task = Task.Run(() => Enumerable.Range(2, 30000).Count(n => Enumerable.Range(2, (int)Math.Sqrt(n) - 1).All(i => n % i > 0)));
            task.ContinueWith(tasks =>
            {
                int result = tasks.Result;
                Console.WriteLine(result);
            });
            Console.ReadLine();
        }

ContinueWith本身返回一个task，它可以用它来附加更多的Continuation。
但是，必须直接处理AggregateException
- 如果 task 发生故障，需要写额外的代码来把 Continuation封装(marshal）到UI应用上。
- 在非UI上下文中，若想让Continuation和 task执行在同一个线程上，必须指定TaskContinuationOptions.ExecuteSynchronously，否则它将弹回到线程池。
ContinueWith 对于并行编程来说非常有用。

TaskCompletionSource(创建Task)

TaskCompletionSource让你在稍后开始和结束的任意操作中创建Task
- 它会为你提供一个可手动执行的“从属”Task
  - 指示操作何时结束或发生故障
它对IO-Bound类工作比较理想
- 可以获得所有Task的好处（传播值、异常、Continuation等)·不需要在操作时阻塞线程

使用TaskCompletionSource

初始化一个实例即可： TaskCompletionSource tcs=new TaskCompletionSource();
有一个Task属性可返回一个Task
该Task完全由TaskCompletionSource 对象控制
对象中的方法只能调用一次，如果多次调用：
- SetXxx会抛出异常
- TryXxx会返回false

        static void Main(string[] args)
        {
            var tcs = new TaskCompletionSource();
            new Thread(() =>
            {
                Thread.Sleep(5000);
                tcs.SetResult(42);
            })
            {
                IsBackground = true
            }.Start();
            Task task = tcs.Task;
            Console.WriteLine(task.Result);
        }

        static void Main(string[] args)
        {
            Task task = Run(() =>
            {
                Thread.Sleep(5000);
                return 42;
            });
            Console.WriteLine(task.Result);
        }
        //调用此方法相当于调用Task.Factory.StastNew.
        //并使用TaskCreationOptions.LongRunning选项来创建非线程池的线程
        static Task Run(Func function)
        {
            var tcs = new TaskCompletionSource();
            new Thread(() =>
            {
                try
                {
                    tcs.SetResult(function());
                }
                catch (Exception ex)
                {
                    tcs.SetException(ex);
                }
            }).Start();
            return tcs.Task;
        }

TaskCompletionSource创建Task,但是并不占用线程（关键）

        static void Main(string[] args)
        {
            var awaiter = GetAnswerToLife().GetAwaiter();
            awaiter.OnCompleted(() =>
            {
                Console.WriteLine(awaiter.GetResult());
            });
            Consle.ReadKey();
        }
        static Task GetAnswerToLife()
        {
            var tcs = new TaskCompletionSource();
            var timer = new System.Timers.Timer(5000) { AutoReset = false };
            timer.Elapsed
                += delegate { timer.Dispose(); tcs.SetResult(42); };
            timer.Start();
            return tcs.Task;
        }

        static void Main(string[] args)
        {
            Delay(5000).GetAwaiter().OnCompleted(() => Console.WriteLine(42));
            //五秒之后，Coninuation开始的时候，才占用线程。
            Console.ReadKey();
        }
        //注意；没有非泛型版本的TaskCompletioSource
        static Task Delay(int Mill) {
            var tcs = new TaskCompletionSource

c#基础学习----Task学习笔记（最全）

.Net相关栏目本月热门文章