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