C# 线程知识--使用Task执行异步操做

            Console.WriteLine("主线程执行其余处理");

  15:              //主线程挂起1000毫秒，等待任务的完成。

  16:              Thread.Sleep(1000);

  17:          }

任务调度结果：

2.等待任务的完成并获取返回值

     使用任务执行异步操做时，最主要的是要后的任务完成时的返回值。在任务类中有一个实例方法Wait（有许多重载版本）他能等待任务的完成，咱们也能够经过Task类的派生类Task<TResult>建立一个异步任务，并指定任务完成时返回值的类型，这样能够经过Task<TResult>的实例对象获取到任务完成后的返回值。建立一个异步任务并执行0到100求和操做返回最后的计算结果，示例代码：

   1:  static void TaskWait() {

   2:              //建立任务

   3:              Task<int> task = new Task<int>(() =>

   4:              {

   5:                  int sum = 0;

   6:                  Console.WriteLine("使用Task执行异步操做.");

   7:                  for (int i = 0; i < 100; i++)

   8:                  {

   9:                      sum+=i;

  10:                  }

  11:                  return sum;

  12:              });

  13:              //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)

  14:              task.Start();

  15:   

  16:              Console.WriteLine("主线程执行其余处理");

  17:              //等待任务的完成执行过程。

  18:              task.Wait();

  19:              //得到任务的执行结果

  20:              Console.WriteLine("任务执行结果：{0}", task.Result.ToString());

  21:  }

执行结果：

Task类还有一些静态方法，WaitAll用于等待提供的全部 System.Threading.Tasks.Task 对象完成执行过程和Wait用于等待提供的任一个 System.Threading.Tasks.Task 对象完成执行过程，这两个方法都有一些重载版本。

//等待全部任务完成  
public static void WaitAll(params Task[] tasks); //等待任意一个任务完成 public static int WaitAny(params Task[] tasks);

3.使用ContinueWith方法在任务完成时启动一个新任务

     在使用可以Task类的Wait方法等待一个任务时或派生类的Result属性得到任务执行结果都有可能阻塞线程，为了解决这个问题可使用ContinueWith方法，他能在一个任务完成时自动启动一个新的任务来处理执行结果。

示例代码：

   1:  static void TaskContinueWith()

   2:          {

   3:              //建立一个任务

   4:              Task<int> task = new Task<int>(() =>

   5:              {

   6:                  int sum = 0;

   7:                  Console.WriteLine("使用Task执行异步操做.");

   8:                  for (int i = 0; i < 100; i++)

   9:                  {

  10:                      sum += i;

  11:                  }

  12:                  return sum;

  13:              });

  14:              //启动任务,并安排到当前任务队列线程中执行任务(System.Threading.Tasks.TaskScheduler)

  15:              task.Start();

  16:              Console.WriteLine("主线程执行其余处理");

  17:              //任务完成时执行处理。

  18:              Task cwt = task.ContinueWith(t => { 

  19:                  Console.WriteLine("任务完成后的执行结果：{0}", t.Result.ToString()); 

  20:              });

  21:              Thread.Sleep(1000);

  22:          }

执行结果：

上述示例中任务不是等待完成来显示执行结果，而是使用ContinueWith方法，它可以知道任务在何时完成并启动一个新的任务来执行任务完成后的处理。ContinueWith方法具备一些重载版本，这些重载版本容许指定延续任务须要使用的数据、延续任务的工做方式（System.Threading.Tasks.TaskContinuationOptions的枚举值按位OR运行的结果）等。

4.建立父子任务和任务工厂的使用

    经过Task类建立的任务是顶级任务，能够经过使用 TaskCreationOptions.AttachedToParent 标识把这些任务与建立他的任务相关联，全部子任务所有完成之后父任务才会结束操做。示例以下：

   1:  static void ParentChildTask() {

   2:              Task<string[]> parent = new Task<string[]>(state => {

   3:                  Console.WriteLine(state);

   4:                  string[] result=new string[2];

   5:                  //建立并启动子任务

   6:                  new Task(() => { result[0]= "我是子任务1。"; },TaskCreationOptions.AttachedToParent).Start();

   7:                  new Task(() => { result[1] = "我是子任务2。"; }, TaskCreationOptions.AttachedToParent).Start();

   8:                  return result;

   9:              },"我是父任务，并在个人处理过程当中建立多个子任务，全部子任务完成之后我才会结束执行。");

  10:              //任务处理完成后执行的操做

  11:              parent.ContinueWith(t => {

  12:                  Array.ForEach(t.Result, r=>Console.WriteLine(r));

  13:              });

  14:              //启动父任务

  15:              parent.Start();

  16:              Console.Read();

  17:          }

执行结果：

    若是须要建立一组具备相同状态的任务时，可使用TaskFactory类或TaskFactory<TResult>类。这两个类建立一组任务时能够指定任务的CancellationToken、TaskCreationOptions、TaskContinuationOptions和TaskScheduler默认值。示例代码:

   1:          static void TaskFactoryApply()

   2:          {

   3:              Task parent = new Task(() =>

   4:              {

   5:                  CancellationTokenSource cts = new CancellationTokenSource(5000);

   6:                  //建立任务工厂

   7:                  TaskFactory tf = new TaskFactory(cts.Token, TaskCreationOptions.AttachedToParent, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);

   8:                  //添加一组具备相同状态的子任务

   9:                  Task[] task = new Task[]{

  10:                      tf.StartNew(() => { Console.WriteLine("我是任务工厂里的第一个任务。"); }),

  11:                      tf.StartNew(() => { Console.WriteLine("我是任务工厂里的第二个任务。"); }),

  12:                      tf.StartNew(() => { Console.WriteLine("我是任务工厂里的第三个任务。"); })

  13:                  };

  14:              });

  15:              parent.Start();

  16:              Console.Read();

  17:          }

执行结果：

5.任务内部实现和任务调度

    任务内部有一组构成任务状态的属性，标识任务的惟一Id、表示任务的执行状态（TaskStatus）、任务建立时提供的回调函数的引用和传递给回调函数的数据对象AsyncState、对任务建立时的任务调度对象（TaskScheduler）的引用、对父任务的引用以及对执行上下文的引用和ManualResetEventSlim对象的引用。Task类和Task<TResult>类都实现了标准的释放资源的接口，容许在任务完成处理的时候使用Dispose方法释放资源（关闭ManualResetEventSlim对象实例）。可使用Task类的CurrentId属性得到正在执行的任务的Id，若是没有任务在执行CurrentId返回值为null，CurrentId是一个int？可空类型的属性。任务执行的生命周期经过TaskStatus类型的一个值来表示，TaskStatus所包含的值：

public enum TaskStatus { Created = 0, WaitingForActivation = 1, WaitingToRun = 2, Running = 3, WaitingForChildrenToComplete = 4, RanToCompletion = 5, Canceled = 6, Faulted = 7, }

      咱们能够经过Task类的Exception属性得到任务在执行过程当中的全部异常

，Exception是一个AggregateException类型的属性。Task类提供了IsCanceled、IsCompleted、IsFaulted属性来得到任务的完成状态。经过ContinueWith、ContinueWhenAll、ContinueWhenAny和FromAsync建立的后续任务都处于WaitingForActivation 状态，这个状态的任务会在父任务完成后自动执行。

      在任务内部由TaskScheduler类调度任务的执行，该类是一个抽象类，FCL中从他派生了两个派生类：ThreadPoolTaskScheduler线程池任务调度器和SynchronizationContextTaskScheduler同步上下文任务调度器。全部任务默认都是采用ThreadPoolTaskScheduler调度任务，他是采用线程池来执行任务，能够经过TaskScheduler类的静态属性Default得到对默认任务调度器的引用。SynchronizationContextTaskScheduler任务调度器可以用在Window form、WPF等应用程序，他的任务调度是采用的GUI线程，因此他能同步更新UI组件，能够经过TaskScheduler类的静态方法FromCurrentSynchronizationContext得到对一个同步上下文任务调度起的引用。

任务调度示例：

   1:    private void button1_Click(object sender, EventArgs e)

   2:          {

   3:               //得到同步上下文任务调度器

   4:             TaskScheduler m_syncContextTaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();

   5:   

   6:              //建立任务，并采用默认任务调度器（线程池任务调度器）执行任务

   7:              Task<int> task = new Task<int>(() =>

   8:              {

   9:                  //执行复杂的计算任务。

  10:                  Thread.Sleep(2000);

  11:                  int sum = 0;

  12:                  for (int i = 0; i < 100; i++)

  13:                  {

  14:                      sum += i;

  15:                  }

  16:                  return sum;

  17:              });

  18:               var cts=new CancellationTokenSource();

  19:              //任务完成时启动一个后续任务，并采用同步上下文任务调度器调度任务更新UI组件。

  20:              task.ContinueWith(t => {this.label1.Text="采用SynchronizationContextTaskScheduler任务调度器更新UI。\r\n计算结果是："+task.Result.ToString(); },

  21:                 cts.Token ,TaskContinuationOptions.AttachedToParent,m_syncContextTaskScheduler);

  22:              task.Start();

  23:          }

执行结果：

    本文简单的介绍了使用Task类来执行异步操做以及任务的内部实现与任务调度。在执行复杂异步操做时，能够采用任务来执行，他能更好的知道异步操做在什么时候完成以及返回异步操做的执行结果。