第六节：深入研究Task实例方法ContinueWith的参数TaskContinuationOptions

一. 整体说明

揭秘：

　　该章节的性质和上一个章节类似，也是一个扩展的章节，主要来研究Task类下的实例方法ContinueWith中的参数TaskContinuationOptions。

　　通过F12查看TaskContinuationOptions的源码，知道主要有这么几个参数：

　　①. LazyCancellation：在延续取消的情况下，防止延续的完成直到完成先前的任务。

　　　　(下面的例子task2取消，原先的延续关系不复存在，task1和task3可以并行执行)

　　②. ExecuteSynchronously：希望执行前面那个task的thread也在执行本延续任务

　　　　(下面的例子执行task2的Thread和执行task1的Thread是同一个，所有二者的线程id相同)

　　③. NotOnRanToCompletion和OnlyOnRanToCompletion

　　　　NotOnRanToCompletion：延续任务必须在前面task非完成状态才能执行

　　　　OnlyOnRanToCompletion：延续任务必须在前面task完成状态才能执行

　　　　(下面例子：注释掉异常的这句代码task2不能执行，task3能执行；不注释，task2能执行，task3不能执行)

 源码如下：

  [Serializable]
     [Flags]
     public enum TaskContinuationOptions
     {
         // 摘要:
         //     Default = "Continue on any, no task options, run asynchronously" 指定应使用默认行为。
         //     默认情况下，完成前面的任务之后将安排运行延续任务，而不考虑前面任务的最终 System.Threading.Tasks.TaskStatus。
         None = ,
         //
         // 摘要:
         //     提示 System.Threading.Tasks.TaskScheduler 以一种尽可能公平的方式安排任务，这意味着较早安排的任务将更可能较早运行，而较晚安排运行的任务将更可能较晚运行。
         PreferFairness = ,
         //
         // 摘要:
         //     指定某个任务将是运行时间长、粗粒度的操作。 它会向 System.Threading.Tasks.TaskScheduler 提示，过度订阅可能是合理的。
         LongRunning = ,
         //
         // 摘要:
         //     指定将任务附加到任务层次结构中的某个父级。
         AttachedToParent = ,
         //
         // 摘要:
         //     如果尝试附有子任务到创建的任务，指定 System.InvalidOperationException 将被引发。
         DenyChildAttach = ,
         //
         // 摘要:
         //     防止环境计划程序被视为已创建任务的当前计划程序。 这意味着像 StartNew 或 ContinueWith 创建任务的执行操作将被视为 System.Threading.Tasks.TaskScheduler.Default
         //     当前计划程序。
         HideScheduler = ,
         //
         // 摘要:
         //     在延续取消的情况下，防止延续的完成直到完成先前的任务。
         LazyCancellation = ,
         //
         // 摘要:
         //     指定不应在延续任务前面的任务已完成运行的情况下安排延续任务。 此选项对多任务延续无效。
         NotOnRanToCompletion = ,
         //
         // 摘要:
         //     指定不应在延续任务前面的任务引发了未处理异常的情况下安排延续任务。 此选项对多任务延续无效。
         NotOnFaulted = ,
         //
         // 摘要:
         //     指定只应在延续任务前面的任务已取消的情况下才安排延续任务。 此选项对多任务延续无效。
         OnlyOnCanceled = ,
         //
         // 摘要:
         //     指定不应在延续任务前面的任务已取消的情况下安排延续任务。 此选项对多任务延续无效。
         NotOnCanceled = ,
         //
         // 摘要:
         //     指定只应在延续任务前面的任务引发了未处理异常的情况下才安排延续任务。 此选项对多任务延续无效。
         OnlyOnFaulted = ,
         //
         // 摘要:
         //     指定只应在延续任务前面的任务已完成运行的情况下才安排延续任务。 此选项对多任务延续无效。
         OnlyOnRanToCompletion = ,
         //
         // 摘要:
         //     指定应同步执行延续任务。 指定此选项后，延续任务将在导致前面的任务转换为其最终状态的相同线程上运行。 如果在创建延续任务时已经完成前面的任务，则延续任务将在创建此延续任务的线程上运行。
         //     只应同步执行运行时间非常短的延续任务。
         ExecuteSynchronously = ,
     }

二. 实际测试

　　下面通过代码来说明默认情况下、LazyCancellation、ExecuteSynchronously、NotOnRanToCompletion和OnlyOnRanToCompletion的作用和效果。

1. 默认情况

　　默认情况下，task1执行完后→task2→task2执行完后→task3。　　

             {
                 Task task1 = new Task(() =>
                 {
                     Thread.Sleep();
                     Console.WriteLine("task1 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 });

                 var task2 = task1.ContinueWith(t =>
                 {
                     Console.WriteLine("task2 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 });

                 var task3 = task2.ContinueWith(t =>
                 {
                     Console.WriteLine("task3 tid={0}， dt={1}  {2}", Thread.CurrentThread.ManagedThreadId, DateTime.Now, task2.Status);
                 });

                 task1.Start();

             }

 运行结果： task1执行完后→ task2执行→task2执行完后→ task3执行。

2. LazyCancellation

　　作用：取消该线程，该线程的前一个线程和后一个线程并行执行。

             {
                 CancellationTokenSource source = new CancellationTokenSource();
                 source.Cancel();

                 Task task1 = new Task(() =>
                 {
                     Thread.Sleep();
                     Console.WriteLine("task1 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 });

                 var task2 = task1.ContinueWith(t =>
                 {
                     Console.WriteLine("task2 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 }, source.Token, TaskContinuationOptions.LazyCancellation, TaskScheduler.Current);

                 var task3 = task2.ContinueWith(t =>
                 {
                     Console.WriteLine("task3 tid={0}， dt={1}  {2}", Thread.CurrentThread.ManagedThreadId, DateTime.Now, task2.Status);
                 });

                 task1.Start();

             }

  运行结果： task2线程已经被取消，task1线程和task2线程并行执行。

3. ExecuteSynchronously

　　作用：希望执行前面那个task的thread也在执行本延续任务。

   {
                 Task task1 = new Task(() =>
                 {
                     Thread.Sleep();
                     Console.WriteLine("task1 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 });

                 var task2 = task1.ContinueWith(t =>
                 {
                     Console.WriteLine("task2 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                 }, TaskContinuationOptions.ExecuteSynchronously);

                 task1.Start();
 }

　　结果：task1和task2线程的线程id相同。

4. NotOnRanToCompletion和OnlyOnRanToCompletion　

　　NotOnRanToCompletion：延续任务必须在前面task非完成状态才能执行。

　　OnlyOnRanToCompletion：延续任务必须在前面task完成状态才能执行。

     {
                Task task1 = new Task(() =>
                    {
                        Thread.Sleep();
                        Console.WriteLine("task1 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                        //手动制造异常，表示不能执行完毕
                        //（注释掉这句话task2不能执行，task3能执行）
                        //不注释，task2能执行，task3不能执行
                        //throw new Exception("hello world");
                    });

                var task2 = task1.ContinueWith(t =>
                {
                    Console.WriteLine("task2 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                }, TaskContinuationOptions.NotOnRanToCompletion);

                var task3 = task1.ContinueWith(t =>
                {
                    Console.WriteLine("task3 tid={0}， dt={1}", Thread.CurrentThread.ManagedThreadId, DateTime.Now);
                }, TaskContinuationOptions.OnlyOnRanToCompletion);

                task1.Start();
}

　　分析：task2和task3均为task的延续线程，当task1报错时候，task2执行，task3不能执行；当task1正常时候，task2不能执行，task3能执行。

　　task1报错时的运行结果：

　　task2正常时的运行结果：